HasPtr& HasPtr::operator=(const HasPtr &rhs)
{
    auto newp=new string(*rhs.ps);      //拷贝底层string
    delete ps;          //释放旧内存
    ps=newp;            //从右侧运算对象拷贝数据到本对象
    i=rhs.i;
    return *this;       //返回本对象
}

void fun1()
{
    HasPtr v1,v2;
    HasPtr temp=v1;     //创建v1的值的一个临时副本
    v1=v2;              //将v2的值赋予v1
    v2=temp;            //将保持的v1的值赋予
}


void fun2()
{
    HasPtr v1,v2;
    string *temp=v1.ps; //为v1.ps中的指针创建一个副本
    v1.ps=v2.ps;        //将v2.ps中的指针赋予v1.ps
    v2.ps=temp;         //将保存的v1.ps的原来的指针赋予v2.ps
}

编写我们自己的swap函数

inline void swap(HasPtr &lhs, HasPtr &rhs)
{
    using std::swap;
    swap(lhs.ps, rhs.ps);   //交换指针，而不是string数据
    swap(lhs.i, rhs.i);     //交换int成员
}

//swap的纯在就是为了优化代码

swap函数应该调用swap，而不是std::swap

class Foo
{
public:
    int h;
};

void swap(Foo &lhs, Foo &rhs)
{
    //错误：这个函数使用了标准库版本的swap，而不是HasPtr版本
    std::swap(lhs.h, rhs.h);
    //交换类型Foo的其他成员
}

class   HasPtr2
{
    friend void fun2();
//    friend void swap(HasPtr2&, HasPtr2&);
public:
//    HasPtr()=default;
    HasPtr2(const string &s=string()):ps(new string(s)), i(0){}
    //对ps指向的string，每个HasPtr对象都有自己的拷贝
    HasPtr2(const HasPtr2 &p):ps(new string(*p.ps)), i(p.i) {}
    HasPtr2 & operator=(HasPtr2 );
    ~HasPtr2() {delete ps;}

private:
    string *ps;
    int     i;
};

<pre name="code" class="cpp">//注意rhs是按值传递的，意味着HasPtr的拷贝构造函数
//将右侧运算对象中的string拷贝到rhs
HasPtr2& HasPtr2::operator=(HasPtr2 rhs)
{
    //交换左侧运算对象和局部变量rhs的内容
    swap(*this, rhs);       //rhs现在指向本对象曾经使用的内存
    return *this;           //rhs被销毁，从而delete了rhs中的指针
}

/**
* 功能:13.3交换操作
* 时间:2014年7月14日09:27:08
* 作者:cutter_point
*/

#include<iostream>
#include<string>

using namespace std;


class   HasPtr
{
    friend void fun2();
    friend void swap(HasPtr&, HasPtr&);
public:
//    HasPtr()=default;
    HasPtr(const string &s=string()):ps(new string(s)), i(0){}
    //对ps指向的string，每个HasPtr对象都有自己的拷贝
    HasPtr(const HasPtr &p):ps(new string(*p.ps)), i(p.i) {}
    HasPtr & operator=(const HasPtr &);
    ~HasPtr() {delete ps;}

private:
    string *ps;
    int     i;
};

/**
类值拷贝赋值运算符
*/
HasPtr& HasPtr::operator=(const HasPtr &rhs)
{
    auto newp=new string(*rhs.ps);      //拷贝底层string
    delete ps;          //释放旧内存
    ps=newp;            //从右侧运算对象拷贝数据到本对象
    i=rhs.i;
    return *this;       //返回本对象
}

void fun1()
{
    HasPtr v1,v2;
    HasPtr temp=v1;     //创建v1的值的一个临时副本
    v1=v2;              //将v2的值赋予v1
    v2=temp;            //将保持的v1的值赋予
}


void fun2()
{
    HasPtr v1,v2;
    string *temp=v1.ps; //为v1.ps中的指针创建一个副本
    v1.ps=v2.ps;        //将v2.ps中的指针赋予v1.ps
    v2.ps=temp;         //将保存的v1.ps的原来的指针赋予v2.ps
}

/**
编写我们自己的swap函数
*/
inline void swap(HasPtr &lhs, HasPtr &rhs)
{
    using std::swap;
    swap(lhs.ps, rhs.ps);   //交换指针，而不是string数据
    swap(lhs.i, rhs.i);     //交换int成员
}

//swap的纯在就是为了优化代码

/**
swap函数应该调用swap，而不是std::swap
*/

class Foo
{
public:
    int h;
};

void swap(Foo &lhs, Foo &rhs)
{
    //错误：这个函数使用了标准库版本的swap，而不是HasPtr版本
    std::swap(lhs.h, rhs.h);
    //交换类型Foo的其他成员
}
/*
编译会通过，且正常运行，但是这里我们显示使用了标准库里面的swap
*/

/**
在赋值运算符中使用swap
*/

class   HasPtr2
{
    friend void fun2();
//    friend void swap(HasPtr2&, HasPtr2&);
public:
//    HasPtr()=default;
    HasPtr2(const string &s=string()):ps(new string(s)), i(0){}
    //对ps指向的string，每个HasPtr对象都有自己的拷贝
    HasPtr2(const HasPtr2 &p):ps(new string(*p.ps)), i(p.i) {}
    HasPtr2 & operator=(HasPtr2 );
    ~HasPtr2() {delete ps;}

private:
    string *ps;
    int     i;
};

/*
定义swap的类通常用swap来定义他们的赋值运算符。
动用了一种拷贝并交技术
*/
//注意rhs是按值传递的，意味着HasPtr的拷贝构造函数
//将右侧运算对象中的string拷贝到rhs
HasPtr2& HasPtr2::operator=(HasPtr2 rhs)
{
    //交换左侧运算对象和局部变量rhs的内容
    swap(*this, rhs);       //rhs现在指向本对象曾经使用的内存
    return *this;           //rhs被销毁，从而delete了rhs中的指针
}

int main()
{
    return 0;
}