1. 拷贝、赋值与销毁
   1. 拷贝构造函数
      1. 拷贝初始化
      2. 参数和返回值
   2. 拷贝赋值运算符
   3. 析构函数
2. 三五法则
3. 拷贝控制和资源管理
4. 交换操作
5. 对象移动
   1. 右值引用
   2. 标准库move函数
   3. 移动构造函数
   4. 移动赋值运算符
   5. 合成的移动操作

class Foo{
public:Foo();                //默认构造函数Foo(const Foo&);    //拷贝构造函数
}

class Sales_data{
public:Sales_data(const Sales_data&);
private:std::string bookNo;int units_sold = 0;double revenue = 0.0;
};//定义Sales_data的拷贝构造函数，与Sales_data的合成拷贝构造函数等价
Sales_data::Sales_data(const Sales_data &orig) :bookNo(orig.bookNo), //使用string的拷贝构造函数units_sold(orig.units_sold),    //拷贝orig.units_soldrevenue(orig.revenue)    //拷贝orig.revenue{}    //空函数体

string dots(10,',');    //直接初始化
string s(dots);            //直接初始化
string s2 = dots;        //拷贝初始化
string null_book = "9-999-99999-9";    //拷贝初始化
string nines = string(100, '9');    //拷贝初始化

Sales_data trans, accum;
trans = accum;    //使用Sales_data的拷贝赋值运算符

class Foo{
public:Foo &operator=(const Foo&);    //赋值运算符// ...
}

//等价于合成拷贝赋值运算符
Sales_data& Sales_data::operator=(const Sales_data &rhs)
{bookNo = rhs.bookNo;    //调用string::operator=units_sold = rhs.units_sold;    //使用内置的int赋值revenue = rhs.revenue;    //使用内置的double赋值return *this;    //返回左侧对象的引用
}

class Foo{
public:~Foo();    //析构函数
    ...
};

{//新作用域//p和p2指向动态分配对象Sales_data *p = new Sales_data;//p是一个内置指针auto p2 = make_shared<Sales_data>();    //p2是一个shared_ptrSales_data item(*p);    //拷贝构造函数将*p拷贝到item中vector<Sales_data> vec;    //局部对象vec.push_back(*p2);        //拷贝p2指向的对象delete p;                //对p指向的对象执行析构函数
}//退出局部作用域；对item、p2和vec调用析构函数
//销毁p2会递减其引用计数；如果引用计数变为0，则对象释放
//销毁vec会销毁它的元素

class Sales_data{
public://成员会被自动销毁，除此之外不需要做其他事情~Sales_data(){}//其他成员的定义
    ...
};

class rule_of_five
{char* cstring; // raw pointer used as a handle to a dynamically-allocated memory blockpublic:rule_of_five(const char* s = ""): cstring(nullptr){ if (s) {std::size_t n = std::strlen(s) + 1;cstring = new char[n];      // allocatestd::memcpy(cstring, s, n); // populate
        } }~rule_of_five(){delete[] cstring;  // deallocate
    }rule_of_five(const rule_of_five& other) // copy constructor
    : rule_of_five(other.cstring){}rule_of_five(rule_of_five&& other) noexcept // move constructor
    : cstring(std::exchange(other.cstring, nullptr)){}rule_of_five& operator=(const rule_of_five& other) // copy assignment
    {return *this = rule_of_five(other);}rule_of_five& operator=(rule_of_five&& other) noexcept // move assignment
    {std::swap(cstring, other.cstring);return *this;}// alternatively, replace both assignment operators with
//  rule_of_five& operator=(rule_of_five other) noexcept
//  {
//      std::swap(cstring, other.cstring);
//      return *this;
//  }
};

class Sales_data{
public:Sales_data() = default;Sales_data(const Sales_data&) = default;Sales_data &operator=(const Sales_data &);~Sales_data() = default;//其他成员
    ...
};
Sales_data &Sales_data::operator=(const Sales_data&) = default;

struct NoCopy{NoCopy() = default;    //合成的默认构造函数NoCopy(const NoCopy&) = delete;    //阻止拷贝NoCopy& operator=(const NoCopy&) = delete;    //阻止赋值~NoCopy() = default;
};

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)
{//这里一定要先new再delete，因为赋值操作赋值给自己是合法的//如果赋值给自己，先delete意味着rhs.ps就丢了auto newp = new string(*rhs.ps);    //拷贝底层stringdelete ps;    //释放旧内存ps = newp;    //从右侧运算对象拷贝数据到本对象i = rhs.i;return *this;    //返回本对象
}

class HasPtr{
public://构造函数分配新的string和新的计数器，将计数器置为1HasPtr(const std::string &s = std::string()):ps(new std::string(s)), i(0), use(new std::size_t(1)){}//拷贝构造函数拷贝所有3个数据成员，并递增计数器HasPtr(const HasPtr &p):ps(p.ps), i(p.i), use(p.use){++*use;}HasPtr& operator=(const HasPtr&);~HasPtr();
private:std::string *ps;int i;std::size_t *use;    //用来记录有多少个对象共享*ps的成员
};HasPtr::~HasPtr()
{if(--*use == 0){    //如果引用计数变为0delete ps;        //释放string内存delete use;        //释放计数器内存
    }
}HasPtr& HasPtr::operator=(const HasPtr &rhs)
{++*rhs.use;    //递增右侧运算对象的引用计数if(--*use == 0){    //然后递减本对象的引用计数delete ps;        //如果没有其他用户delete use;        //释放本对象分配的成员
    }ps = rhs.ps;    //将数据从rhs拷贝到本对象i = rhs.i;use = rhs.use;return *this;    //返回本对象
}

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

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

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

int i = 42;
int &r = i;        //正确：r引用i，r是左值引用
int &&rr = i;    //错误：右值引用不能绑定到左值上
int &r2 = i*42;    //错误：i*42是右值
const int &r3 = i*42;    //正确：可以将一个const引用绑定到一个右值上
int &&rr2 = i*42;    //正确：将rr2绑定到乘法结果上

int &&rr1 = 42;        //正确：字面常量是右值
int &&rr2 = rr1;    //错误：表达式rr1是左值

int &&rr3 = std::move(rr1);    //正确

StrVec::StrVec(StrVec &&s) noexcept    //移动构造不应该抛任何异常//成员初始化器接管s中资源
  : elements(s.elements), first_free(s.first_free), cap(s.cap)
{//令s进入这样一个状态————对其运行析构函数是安全的s.elements = s.first_free = s.cap = nullptr;
}

StrVec &StrVec::operator=(StrVec &&rhs) noexcept
{//直接检测自赋值if(this != &rhs){free();    //释放已有元素elements = rhs.elements;    /从rhs接管资源first_free = rhs.first_free;cap = rhs.cap;//将rhs置于可析构状态rhs.elements = rhs.first_free = rhs.cap = nullptr;}return *this;
}

//编译器为X和hasX合成移动操作
struct X{int i;    //内置类型可以移动std::string s;    //string定义了自己的移动操作
};
struct hasX{X mem;    //X有合成的移动操作
};
X x, x2 = std::move(x);    //使用合成的移动构造函数
hasX hx, hx2 = std::move(hx);    //使用合成的移动构造函数

StrVec v1, v2;
v1 = v2;    //v2是左值，使用拷贝赋值
StrVec getVec(istream &s);    //getVec返回一个右值
v2 = getVec(cin);    //getVec(cin)是一个右值，使用移动赋值

class Foo{
public:Foo() = default;Foo(const Foo&);...
};
Foo x;
Foo y(x);    //拷贝构造函数，x是左值
Foo z(std::move(x));    //拷贝构造函数，因为未定义移动构造函数

class Foo
{
public:Foo &operator=(const Foo&) &; // 只能向可修改的左值赋值// 其他成员
};Foo &Foo::operator=(const Foo &rhs) &
{// 执行将rhs赋予本对象所需的工作return *this;
}

class Foo
{
public:Foo someMem() & const;      // errorFoo anotherMem() const &;   // ok
};

class Foo
{
public:Foo sorted() &&;        // 可用于可改变的右值Foo sorted() const &;   // 可用于任何类型的Foo//Foo其他成员
private:vector<int> data;
};//本对象为右值，因此可以原址排序
Foo Foo::sorted() &&
{sort(data.begin(), data.end());return *this;
}
//本对象是const或是一个左值，哪种情况我们都不能对其进行原址排序
Foo Foo::sorted() const &{Foo ret(*this);sort(ret.data.begin(), ret.data.end());return ret;
}retVal().sorted();    //retVal()是右值，调用Foo::sorted() &&
retFoo().sorted();    //retFoo()是左值，调用Foo::sorted() const &

class Foo
{
public:Foo sorted() &&;Foo sorted() const;    // 错误：必须加上引用限定符// Comp是函数类型的类型别名// 此函数类型可以用来比较int值using Comp = bool(const int&, const int&);Foo sorted(Comp*);          // 正确：不同的参数列表Foo sorted(Comp*) const;    //正确：两个版本都没有引用限定符
};