【C++ Primer 第13章】1. 拷贝控制、赋值和销毁

拷贝控制、赋值和销毁

• 如果一个构造函数的第一个参数是自身类的引用，且额外的参数都有默认值，则此构造函数是拷贝控制函数(拷贝构造函数不应该是explicit的)。
• 如果我们没有为一个类定义拷贝构造函数，编译器会为我们定义一个，与合成默认构造函数不同， 即使我们定义了其他构造函数，编译器也会为我们合成一个拷贝构造函数。

 class Sales_data
 {
 public:
     Sales_data(const Sales_data&);
 private:
     string bookNo;
     int units_sold = ;
     double revenue = 0.0;
 };

 Sales_data::Sales_data(const Sales_data &rhs):
 bookNo(rhs.bookNo),       //ISBN号
 units_sold(rhs.units_sold), //销量
 revenue(rhs.revenue) //总销售收入
 {}

　　

析构函数

• 当一个类定义自己的析构函数时，编译器会为它定义一个合成析构函数。

---

练习参考答案

13.13

 #include<iostream>
 #include<string>
 #include<vector>
 using namespace std;

 struct X
 {
     X() { cout << "默认构造函数X()" << endl; }
     X(const X&) { cout << "拷贝构造函数 X(const X&)" << endl; }
     X& operator=(const X &rhs) { cout << "拷贝赋值运算符=(const X&)" << endl; return *this; }
     ~X() { cout << "析构函数 ~()" << endl; }
 };

 void f1(X x)
 {}

 void f2(X &x)
 {}

 int main()
 {
     cout << "局部变量" << endl;
     X x;
     cout << endl;

     cout << "非引用参数传递：" << endl;
     f1(x);
     cout << endl;

     cout << "引用参数传递" << endl;
     f2(x);
     cout << endl;

     cout << "动态内存：" << endl;
     X *px = new X(x);
     cout << endl;

     cout << "添加到容器中：" << endl;
     vector<X> vx;
     vx.push_back(x);
     cout << endl;

     cout << "释放动态内存" << endl;
     delete px;
     cout << endl;

     cout << "间接初始化和赋值：" << endl;
     X y = x;
     y = x;
     cout << endl;

     cout << "程序结束" << endl;
     return ;
 }

运行结果：

---

　　

三五法则

• 如果一个类需要自定义析构函数，几乎可以肯定它也需要自定义拷贝赋值运算符和拷贝构造函数。

• 如果一个人类需要一个拷贝构造函数，几乎可以肯定它也需要一个拷贝赋值运算符。

• 如果一个类需要一个拷贝赋值运算符，几乎可以肯定它也需要一个拷贝构造函数。

 练习参考答案

//13.14: 0 0 0

//13.15: 3 4 5

//13.16: 0 1 2

#include<iostream>
using namespace std;

class numbered
{
private:
	static int seq;
public:
	numbered() { mysn = seq++; }
	numbered(numbered &n) { mysn = seq++; }
	int mysn;
};

int numbered::seq = 0;

void f(numbered s)
{
	cout << s.mysn << endl;
}

int main(int argc, char **argv)
{
	numbered a, b = a, c = b;
	f(a);
	f(b);
	f(c);
	return 0;
}

　

使用=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& Sales_data::operator=(const Sales_data &) = default;

阻止拷贝

如果一个类有数据成员不能默认构造、拷贝、复制和销毁，则对应的成员函数将被定义为删除的。规则引申如下:

• 如果类的某个成员的析构函数时删除的或不可访问的，则类的合成析构函数被定义为删除的；同时类的默认构造函数是删除的；同时类的合成拷贝构造函数也被定义为删除的。（析构函数被定义为删除的，则不能定义该类型的变量。）
• 如果类的某个成员的拷贝构造函数是删除的或不可访问的，则类的合成拷贝构造函数被定义为删除的；
• 如果类的某个成员的拷贝赋值运算符是删除的或不可访问的，或类有一个const的或引用成员，则类的合成拷贝赋值运算符被定义为删除的；
• 如果类有一个引用成员，它没有类内初始化器，或是类有一个const成员，没有类内初始化器且其类型未显式定义默认构造函数，则该类的默认构造函数是删除的。

练习参考答案

【练习13.5】

 class HasPtr
 {
 public:
     HasPtr(const string &s = string()): ps(new string(s)), i() {}
     HasPtr(const HasPtr &rhs): ps( new string(*rhs.ps)), i(rhs.i) {}
 private:
     string *ps;
     int i;
 }

【练习13.8】

 class HasPtr
 {
 public:
     HasPtr(const string &s = string()): ps(new string(s)), i() {}
     HasPtr(const HasPtr &rhs): ps( new string(*rhs.ps)), i(rhs.i) {}

     HasPtr operator=(const HasPtr &rhs);
 private:
     string *ps;
     int i;
 }

 HasPtr HasPtr::operator=(const HasPtr &rhs)
 {
     ps = new string(*rhs.ps);
     i = rhs.i;
     return *this;