1.当定义一个类时，会通过五种特殊的成员函数来控制此类型的对象的拷贝、移动、赋值和销毁：拷贝构造函数、拷贝赋值运算符、移动构造函数、移动赋值运算符和析构函数
2.拷贝构造函数
2.1 拷贝构造函数的第一个参数必须是自身类型的引用，此参数几乎总是一个const引用，且任何额外参数都有默认值
与合成默认构造函数不同，即使我们定义了其他构造函数，编译器也会为我们合成一个拷贝构造函数
class Sales_data
{
public:
Sales_data();
virtual ~Sales_data();
//与合成的拷贝构造函数等价的拷贝构造函数的声明
Sales_data(const Sales_data&);
protected:
private:
std::string bookNo;
int units_sold=0;
double revenue=0.0;
};
//与Sales_data的合成的拷贝构造函数等价
Sales_data::Sales_data(const Sales_data &orig):
bookNo(orig.bookNo),
units_sold(orig.units_sold),
revenue(orig.revenue)
{
}
2.2 拷贝初始化
此时我们知道了拷贝初始化和赋值初始化的区别
//直接初始化，实际上是要求编译器使用函数匹配来选择对应的构造函数
string dots(10,'.');
//拷贝初始化,实际上是要求编译器将右侧对象拷贝到正在创建的对象中，如果需要还要进行类型转化
//拷贝初始化通常是由拷贝构造函数完成，但如果一个类有一个移动构造函数，则拷贝初始化时可能使用后者
string nines = string(100,'9');
拷贝初始化不仅在使用=定义变量时会发生，下列情况也会发生：将一个对象作为实参传递给一个非引用类型的形参、从一个返回类型为非引用类型的函数返回一个对象、从花括号列表初始化一个数组中的元素或一个聚合类的成员
2.3 返回值
拷贝构造函数用来初始化费引用类型参数，如果其参数不是引用类型，则调用永远不会成功：为了调用拷贝构造函数，我们必须拷贝他的实参，但为了拷贝实参又必须调用拷贝构造函数，如此会无限循环。
3. 拷贝赋值运算符
如果类未定义自己的拷贝赋值运算符，编译器会为它合成一个。
3.1 重载赋值运算符
重载运算符本质是函数，函数名由operator加上符号组成，因此赋值运算符就是名为operator=的函数
赋值运算符通常应该返回一个指向其左侧运算对象的引用
class Foo {
public:
Foo& operator=(const Foo&); //赋值运算符
};
类似拷贝构造函数，若自己未定义，编译器会定义拷贝赋值运算符；同样的，对于某些类，合成拷贝赋值运算符用来禁止该类型的对象赋值，如果拷贝赋值运算符并非此目的，则会将右侧对象的每个非static成员赋予给左侧对象的对应成员
//等价于合成赋值拷贝运算符
Sales_data& Sales_data::operator=(const Sales_data &rhs){
bookNo=rhs.bookNo;
units_sold=rhs.units_sold;
revenue=rhs.revenue;
return *this;
}
4.析构函数
析构函数释放对象使用资源，并销毁对象的非static数据成员
它没有返回值，也不接受参数，函数名前有~；由于没有参数因此不能被重载，一个类只会有唯一的析构函数
//等价于合成析构函数
class Sales_data{
public:
//成员会自动销毁，除此之外不需要做其他的事
~Sales_data() {}
};
析构函数自身并不直接销毁成员，成员是在析构函数体之后隐含的析构阶段中被销毁的。在整个对象销毁过程中，析构函数体是作为成员销毁步骤之外的另一部分而进行的。
5.三/五法则
有三个基本操作可以控制类的拷贝操作：拷贝构造函数、拷贝赋值运算符和析构函数；在新标准下还可以定义一个移动构造函数和一个移动赋值运算符；并不要求定义所有，但是只需要其中一个操作，而不需要定义所有操作的情况很少见。
当我们决定一个类是否要定义他自己版本的拷贝控制成员时，一个基本原则是首先确定这个类是否需要一个析构函数
如果一个类需要自定义析构函数，几乎可以肯定他也需要自定义拷贝赋值运算和拷贝构造函数
class HasPtr{
public:
HasPtr(const std::string &s = std::string()):
ps(new std::string(s)),i(0){}
//错误：HasPtr需要一个拷贝构造函数和一个拷贝赋值运算符
~HasPtr(){delete ps}
private:
std::string *ps;
int i;
};
//这个版本类使用合成构造函数和合成赋值运算符，这些函数简单拷贝指针成员，这意味着对个HasPtr对象可能指向相同的内存
//错误case:连续delete两次
//当f返回时，hp和ret都会被销毁，但是二者包含相同指针值，最终导致此指针被delete两次
HasPtr f(HasPtr hp){
HasPtr ret=hp;
return ret;
}
//另外
HasPtr p("hello");
f(p); //当f结束，p.ps指向内存会被释放
HasPtr q(p); //现在p和q都指向无效内存
如果一个类需要自定义拷贝赋值运算符，那么他一定需要拷贝构造函数，反之亦然；但是不意味着需要析构函数
6.使用default
可以将拷贝控制成员定义为=default来显示要求编译器生成合成的版本
class Sales_data{
public:
//拷贝控制成员使用default
Sales_data()=default;
Sales_data(const Sales_data &)=default;
Sales_data& operator=(const Sales_data&);
~Sales_data()=default;
};
Sales_data& operator=(const Sales_data&) = default;
如果我们不希望合成成员是内联函数，应该只对成员的类外定义使用=default
只能对具有合成版本的成员函数使用=default（即默认构造函数或拷贝控制成员）
?7.阻止拷贝
有时，定义类时必须采用某种机制组织拷贝或者赋值，例如iostream阻止了拷贝以避免多个对象写入或者读取相同的io缓冲。即使不定义拷贝控制成员，编译器也会生成合成的。
7.1 定义删除的函数
在新标准下，我们可以使用=delete来声明我们不希望以任何方式使用此函数，用法类似=default，但是与=default有两点不同：=delete必须出现在函数第一次声明的时候；我们可以对任何函数指定=delete
但是析构函数不能是删除的成员
7.2 private拷贝控制
在新标准前，类是通过将拷贝构造函数和拷贝赋值运算符生命为private来组织拷贝的。但是友元和成员函数仍然可以拷贝对象，为了阻止他们，我们讲这些拷贝控制成员声明为private的，但是不定义他。
8. 拷贝控制和资源管理
通常，管理类外资源的类必须定义拷贝控制成员，可以这种类可以看起来像值，也可以看起来像指针。
8.1 行为像值的类
定义行为像值的类需要拷贝其底层指针指向的对象
编写赋值运算符时，注意两点：如果将一个对象赋予了自身，赋值运算符必须正常工作；大多赋值运算符组合了析构函数和拷贝构造函数的工作。
注意如果使用赋值运算符赋予自身，不能先delete，这样的话会导致自身指针指向的对象被释放，从而无从拷贝，只剩一个空指针了。正常做法是先将右侧值拷贝到局部变量，然后delete自身指向的对象，最后将局部变量拷贝给本对象
class HasPtr {
public :
HasPtr(const std::string &s = std::string()):
ps(new std::string(s)), i(0){}
//对ps指向的string，每个HasPtr对象都有自己的拷贝
HasPtr(const HasPtr &p):
ps(new std::string(*p.ps)),i(p.i){}
HasPtr& operator=(const HasPtr &);
~HasPtr() {delete ps;}
private:
std::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;
}
8.2 行为像指针的类
定义行为像指针多的类需要拷贝指针成员本身，此时析构函数不能单方面的释放关联的string，只有当最后一个指向string的HasPtr销毁时，他才可以释放string （类似于shared_ptr），有时我们希望直接管理资源（即不使用shared_ptr），就可以使用引用计数。
引用计数不能是HasPtr对象的成员，否则，p1先后拷贝给p2,p3，当p3的计数更新后，无法更新p2的计数。可以将计数器保存在动态内存中，当拷贝或者赋值对象时，我们拷贝指向计数器的指针，这样副本和原对象都会指向相同的计数器。
class HasPtr {
public :
HasPtr(const std::string &s = std::string()):
ps(new std::string(s)), i(0), use(new std::size_t(1)) {}
//拷贝构造函数拷贝所有三个数据成员，并递增计数器
HasPtr(const HasPtr &p):
ps(p.ps),i(p.i),use(p.use){ ++*use;}
HasPtr& operator=(const HasPtr &);
~HasPtr() {delete ps;}
private:
std::string *ps;
int i;
std::size_t *use; //用来记录有多少个对象共享*ps的成员
};
HasPtr::~HasPtr(){
if(--*use == 0){
delete ps;
delete use; //释放计数器内存别忘了
}
}
//赋值运算符需要递增右侧运算对象的引用计数，递减本对象的引用计数
HasPtr& HasPtr::operator=(const HasPtr &rhs){
++*rhs.use;
//析构
if(--*use == 0){
delete ps;
delete use;
}
//构造
ps=rhs.ps;
i-rhs.i;
use=rhs.use;
return *this;
}
9. 交换操作
除了定义拷贝控制成员，管理资源的类通常还定义一个名为swap的函数。
如果一个类定义了自己的swap，那就会使用自定义版本，否则使用标准库版本，我们希望swap交换指针，而非需要开辟临时对象来转存(开辟临时对象转存如：HasPtr tmp=v1;v1=v2;v2=tmp)。（swap并不是必须，但是可以通过定义swap进行代码优化），如果需要优化，此时swap函数应该调用自定义的swap，而非标准库的std::swap.
class HasPtr {
public :
//定义swap为friend，以便能访问到HasPtr的peivate数据成员
friend void swap(HasPtr&, HasPtr&);
//其他定义同上
};
inline
void swap(HasPtr &lhs,HasPtr &rhs){
using std::swap;
swap(lhs.ps, rhs.ps);
swap(lhs.i, rhs,i);
}
在赋值运算符中使用swap，这种称作是拷贝并交换的计数，将左侧运算对象与右侧对象的副本进行交换。注意，其中的参数并不是一个引用，这个技术有趣在于自动处理里了自赋值情况且天然就是异常安全的（在改变左侧运算对象之前，先拷贝右侧运算对象从而保证自赋值的安全，实际上和前面的方法是一致的）。
HasPtr& HasPtr::operator=(HasPtr rhs){
swap(*this,rhs); //rhs现在指向本对象曾经使用的内存
return *this; //rhs被销毁，从而delete了rhs中的指针
}
|