C++学习基础六——复制构造函数和赋值操作符

1.什么是复制构造函数

复制构造函数：是构造函数，其只有一个参数，参数类型是所属类的类型，且参数是一个const引用。

作用：将本类的成员变量赋值为引用形参的成员变量。

2.什么是赋值操作符

赋值操作符：返回值是本类的引用类型，参数类型是所属类的类型，且参数是一个const引用。

作用与复制构造函数相同。

其声明如下：

1 Sales_item& operator=(const Sales_item& rig);

3.什么情况下需要我们自己实现复制构造函数和赋值操作符？

一般情况下，C++会帮助我们实现复制构造函数和赋值操作符，但是当我们定义的类的成员变量中包含指针时，必须自己实现复制构造函数和赋值操作符，同时也要实现析构函数。

4.代码如下：

（1）自定义Sales_item类，实现了构造函数，析构函数，复制构造函数和赋值操作符。

 1 #include <iostream>
 2 #include <string>
 3 using namespace std;
 4 class Sales_item
 5 {
 6 public:
 7     Sales_item()
 8     {
 9         this->number = 0;
10         this->acount = 0.0;
11     }
12
13     Sales_item(const string &isbnstr)
14     {
15         this->isbn = isbnstr;
16         this->number = 0;
17         this->acount = 0.0;
18     }
19
20     //复制构造函数：如果自己不写，C++会默认提供一个
21     //复制构造函数：只接收一个参数 ，参数的类型是当前类，并且是一个const的引用
22     //作用：是将形参的数据成员一一赋给当前的数据成员
23     Sales_item(const Sales_item& other)
24     {
25         isbn = other.isbn;
26         number = other.number;
27         acount = other.acount;
28         cout<<"复制构造函数被调用...."<<endl;
29     }
30
31
32 　　//赋值操作符：如果自己不写，C++会默认提供一个
33 　　//返回值是本类的引用，接收一个参数，参数的类型是当前类，并且是一个const的引用
34     Sales_item& operator= (const Sales_item &other)
35     {
36         isbn = other.isbn;
37         number = other.number;
38         acount = other.acount;
39         cout<<"赋值操作符 被调用...."<<endl;
40         return *this;
41     }
42
43     //一般情况下，C++会帮我们实现 复制构造函数和赋值操作符
44     //但是当一个类的数据成员有指针的时候，我们必须自己实现复制构造函数和赋值操作符
45 private:
46     string isbn;
47     int number;
48     double acount;
49 };

(2)主方法：

1 int main()
2 {
3     Sales_item a;
4     Sales_item b("0-12-djf-X");
5     Sales_item c(b); //调用复制构造函数
6     a = b; //调用赋值操作符
7     return 0;
8 } 

5.带有指针成员变量的自定义类：

 1 class NoName
 2 {
 3 public :
 4     NoName()
 5     {
 6         sPtr = new string;
 7         number = 0;
 8     }
 9     ~NoName()
10     {
11         delete sPtr;
12     }
13     //复制构造函数
14     NoName(const NoName& str)
15     {
16         sPtr = new string;
17         *sPtr = *(str.sPtr);//注意：进行的是指针所指向值的赋值,而不是指针的重新赋值
18          number = str.number;
19     }
20
21     //赋值操作符
22     NoName& operator=(const NoName &rig)
23     {
24         sPtr = new string;
25         *sPtr = *(rig.sPtr);//注意：进行的是指针所指向值的赋值,而不是指针的重新赋值
26          number = rig.number;
27          return *this;
28     }
29 private:
30     string *sPtr;
31     int number;
32 }; 

6.总结复制构造函数和赋值操作符

复制构造函数：是指将构造函数的参数一一给本类的对象的赋值，对于指针而言，不是指针的赋值，而是指针所指向的数据的赋值。
具体代码如下：

 1 class NoName{
 2 private:
 3 　　string *str;
 4 　　int i;
 5 　　double b;
 6 };
 7 NoName(const NoName &other)
 8 {
 9 　　str = new string;
10　　 *str = *(other.str);
11 　　i = other.i;
12 　　b = other.b;
13 }

赋值操作符： 函数声明

 1 NoName& operator=(const NoName &rig);
 2 NoName& operator=(const NoName &rig)
 3 {//内容跟复制构造函数的一样
 4     str = new string;
 5     *str = *(rig.str);
 6     i = rig.i;
 7     b = rig.b;
 8
 9     return *this;
10 }

7.析构函数三原则：

如果写了析构函数，则同时必须写复制构造函数和赋值操作符。