Part 6: 拷贝控制(第13章)

// @author:       gr// @date:         2015-01-08// @email:        forgerui@gmail.com

一、拷贝、赋值与销毁

1. 拷贝构造函数
2. 拷贝赋值运算符
3. 析构函数
   析构函数自身并不直接销毁成员，而是在析构函数之后隐含的析构阶段中被销毁的。
4. 使用=default修饰成员时，要求编译器生成合成的版本。

5. 阻止拷贝

   在新标准下，使用删除的函数来阻止拷贝，虽然声明了它，但不能以任何方式使用它。

   struct NoCopy{     NoCopy() = delete;     Nocopy(const NoCopy&) = delete;                 //阻止拷贝     NoCopy& operator=(const Nocopy&) = delete;      //阻止赋值 };

   将拷贝函数声明为private,阻止调用，并且只声明不实现。

二、拷贝控制和资源管理

1. 一旦一个类需要析构函数，那么它几乎肯定也需要一个拷贝构造函数和一个拷贝赋值运算符。
2. 定义拷贝操作，使类的行为看起来像一个值或指针。像值的类拥有自己的状态，像指针的类则共享状态（当拷贝一个这种类的对象时，副本和原对象使用相同的底层数据）。

3. 行为像值的类，有两个数据成员string、int

   class HasPtr{     public:         HasPtr(const std::string &s = std::string()) : ps(new string(s)), i(0){}         HasPtr(const HasPtr& p) : ps(new string(*p.ps)), i(p.i){}         HasPtr& operator= (const HasPtr&);         ~HasPtr(){  delete ps;}     private:         int i;         std::string* ps; }; HasPtr& HasPtr::operator=(const HasPtr& rhs){     std::string* newp = new std::string(*rhs.ps);       //先创建一个新拷贝之后再delete,否则如果传入自己，delete会使rhs.ps失效，再拷贝就什么也没有了。     delete ps;           ps = newp;     i = rhs.i;     return *this; }

   注意：
   1. 如果一个对象赋予它自身，赋值运算符必须能正确工作。
   2. 大多数赋值运算符组合了析构函数和构造函数的工作。

4. 行为像指针的类，多个对象共享一份资源，需要使用引用计数。可以用shared_ptr，也可以自己实现。

   class HasPtr{     public:         HasPtr(const std::string& s = std::string()) : ps(new string(s)), use(new std::size_t(1)), i(0){}         HasPtr(const HasPtr& rhs) : ps(rhs.ps), use(rhs.use), i(rhs.i){ ++*use; }         HasPtr& operator=(const HasPtr&);         ~HasPtr();     private:         int i;         string* ps;         std::size_t* use; }; //析构函数 HasPtr::~HasPtr(){     if (--*use == 0){         delete ps;         delete use;     } } //拷贝运算符 HasPtr& HasPtr::operator=(const HasPtr& rhs){     ++*rhs.use;     //先判断是否是最后一个拥有资源的类，如果是，则删除资源     if (--*use){         delete ps;         delete use;     }     ps = rhs.ps;     use = rhs.use;     i = rhs.i;     return *this; }

三、交换操作SWAP

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

   定义类自己的swap函数，如下：

   class HasPtr{     public:         friend void swap(HasPtr& lhs, HasPtr& rhs); }; inline void swap(HasPtr& lhs, HasPtr& rhs){     using std::swap;     swap(lhs.ps, rhs.ps);     swap(lhs.i, rhs.i); }

   每个swap函数都应该是未加限制的，这样如果存在类型特定的swap版本，则优先于特定的swap版本。

2. 在赋值中使用swap

   HasPtr& HasPtr::operator=(HasPtr rhs){     //参数是一个值，而不是引用     swap(*this, rhs);     return *this; }

四、对象移动

1. 新标准中的一个特性是可以移动而非拷贝对象的能力。这样会大幅度提升性能。

2. 为了支持移动操作，新标准引入了一种新的引用类型，右值引用，就是必须绑定到右值的引用。通过&&而不是&来获得引用。

   int &&rr = i * 42;
   int &&rr1 = 42; //正确：字面常量是右值
   int &&rr2 = rr1; //错误：变量是左值

3. 标准move函数

   可以通过move显式地将右值引用绑定到一个左值上。

   int &&rr3 = std::move(rr1);

4. 移动构造函数和移动赋值运算符

   移动构造函数的参数是该类类型的一个右值引用。

   StrVec::StrVec(StrVec &&s) noexcept     //移动操作不应抛出任何异常     : elements(s.elements), first_free(s.first_free), cap(s.cap) {     //令s进入这样的状态，对其运行析构函数是安全的     s.elements = s.first_free = s.cap = nullptr; //置为nullptr后，便可析构rhs，不会影响 } //移动赋值运算符 StrVec& StrVec::operator=(StrVec&& rhs) noexcept{     if (this != &rhs){         free();         elements = rhs.elements;         first_free = rhs.first_free;         cap = rhs.cap;         rhs.elements = rhs.first_free = rhs.cap = nullptr;       }     return *this; }