【C++编程】1. 拷贝控制、赋值和销毁

拷贝控制、赋值和销毁

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

class Sales_data
{
public:
    Sales_data(const Sales_data&);
private:
    string bookNo;
    int units_sold = 0;
    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 0;
}

运行结果：

---

 

　　

 

 

 

 

 

三五法则

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

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

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

 

 练习参考答案

//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(0) {}
    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(0) {}
    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;