C++primer -拷贝控制

拷贝控制成员：类通过五种函数来控制对象的拷贝、移动、赋值和销毁：拷贝构造函数、拷贝赋值运算符、移动构造函数、移动赋值运算符、析构函数

合成拷贝控制成员：

• 若一个类未显式定义拷贝控制成员，编译器会自动生成合成版本；

• 若类含有指向动态内存的指针，必须显式定义其拷贝控制成员：

拷贝构造函数和拷贝赋值运算符的合成版本是将成员一 一拷贝；因此当对象的成员是指针，而该指针指向对象的动态内存资源，可能出现合成的版本只拷贝了指针，没有将指针所指对象拷贝。通常我们希望发生的是深拷贝，但合成拷贝函数中发生的是浅拷贝。如果是拷贝赋值，合成的版本不会清理拷贝源所指的动态内存，还存在着内存泄漏的风险。因此对于含有 指向动态内存的指针 的成员 的对象，必须显式定义它的拷贝构造、拷贝赋值和析构函数。

典例：

string类型内保存的是指针data，data指向一块char数组类型的动态内存，若只是简单地拷贝string对象的成员data指针而没有在拷贝赋值运算符中自定义释放char动态内存，那么a = b;操作中b的成员data指针指向char类型的动态内存将不会被释放。

拷贝构造函数：

定义：构造函数第一个参数是自身类型的引用，且其他参数都有默认值。

class B{

public:

    B(B &b){}

};

B f(B a3){};

B a1(b);// 显式调用拷贝构造函数

B a2 = b;// 隐式调用拷贝构造函数

f(b);// 隐式调用拷贝构造函数

拷贝初始化的限制：

B a1 = b;

 /* 
 * b是B类型的对象，若只定义了拷贝构造函数但未定义拷贝赋值运算符，该语句是错误的，
 * 因为拷贝构造函数不支持隐式转换。
 * 但有些编译器可以将这种用于初始化的赋值语句等价为调用拷贝构造函数。此时这种语句被允许
 */

vector<int> b;

void f(vector<int> v);// v除支持隐式转换的构造函数外，只支持拷贝初始化

f({10, 2});// 正确，vecotr<int>的列表初始化支持隐式转换

f(10);// 错误，该构造函数不支持隐式转换

拷贝赋值运算符：

实例：class Foo{ public: Foo& operator = (const Foo&); }

类的拷贝赋值运算符的合成版本会将其成员拷贝，并返回该类对象的引用；

析构函数：

class Foo{

public:

    ~Foo(){}

};

析构函数不允许有参数，不允许重载。

析构函数释放的顺序与构造函数构造的顺序相反，先执行函数体再释放成员，先delete动态分配的对象，再释放非静态成员。

一个对象的指针或引用在离开作用域时不会自动执行对象的析构函数；

有析构函数的类，即使是虚析构函数，也不会被合成移动操作。

一个需要自定义析构函数的类也需要自定义拷贝和赋值操作：

class HashPtr{

public:

    HashPtr(const string& s = string()):ps(new string(s)){}

    ~HashPtr(){ delete ps;}

    string *ps;

};

HashPtr f(HashPtr hp){// hp是一个局部对象，离开作用域时将被销毁

    HashPtr ret = hp;// ret也是一个局部对象，离开作用域时将被销毁

    return ret;// ret、hp离开作用域，执行析构函数，delete ret、delete hp 
    // 导致ret、hp所指对象被销毁且出现二次销毁

}

需要拷贝操作的类也需要赋值操作：

考虑一个给每个对象一个唯一id的类，其拷贝和赋值操作都需要对id执行自定义拷贝操作。

使用=default使编译器生成默认的合成拷贝构造函数、默认的合成拷贝赋值运算符以及默认的析构函数：

class Sales_data{

public:

    Sales_data(const Sales_data&) = default;

    Sales_data& operator = (Sales_data&) = default;

    ~Sales_data() = default;

};

使用=delete阻止拷贝以及析构(使编译器也不能生成合成版本) --（旧版本只能将拷贝构造函数或拷贝赋值运算符声明为私有，但仍存在被类的成员使用的情况）：

class Foo{

    Foo(const Foo&) = delete;

    Foo& operator = (const Foo&) = delete;

    ~Foo() = delete;

};

// 对析构函数进行了delete的类不能定义它的局部变量以及不能释放指向该类型动态分配对象的指针（局部变量离开作用域会调用析构函数，使用delete释放对象也会调用对象的析构函数）。

注意：= delete必须出现在函数第一次声明的时候

阻止拷贝实例：io类阻止拷贝，以避免缓冲区出现同时写入、读取的情况。

本质上，当类的成员不能拷贝、赋值和销毁时，类的合成拷贝控制成员就应当定义为删除的；

定义拷贝操作的两种选择：

1、每个对象都有一份自己的内容 --深拷贝

2、多个对象共享一份内容 --浅拷贝

定义拷贝赋值运算符要注意自我赋值的情况：

class HashPtr{

public:

    HashPtr(const string& s = string()):ps(new string(s)){}

    ~HashPtr(){ delete ps;}

    HashPtr(const HashPtr& hp):ps(new string(*hp)){}

    HashPtr& operator = (const HashPtr& hp){

        auto tps = new string(*hp.ps);

        delete this.ps;

        this.ps = tps;  

    } /* 注意：调用拷贝赋值运算符的对象本身存在一个值.
若该值是指向一个动态对象的指针，需要先释放掉该指针原来的对象，再指向之后的对象.
其中注意对自身的拷贝，对自身拷贝时，擦除了拷贝目标的源数据,就是擦除了拷贝源数据，那么拷贝将把该对象的值擦除。
因此定义拷贝赋值运算符时，必须注意拷贝自身的情况，而避免拷贝自身的擦除，可以使用：

        - 先检查是否是自拷贝，是则直接返回当前对象；
        - 拷贝源对象，保存副本。之后再擦除拷贝目标的值，最后将保存的副本用于创建目标对象新的值。
          */

    string *ps;

}；