C++ 类和对象（中）（拷贝构造函数、赋值运算符重载） ...

目录
     
一、媒介
二、正文
1.拷贝构造函数
1.1拷贝构造函数的使用
1.2对于传引用返回的问题
2.赋值运算符重载
2.1运算符重载
2.1.1运算符重载的使用
2.2赋值运算符重载
2.2.1赋值运算符的使用
3.注意事项（构造函数和赋值运算符重载的误判） 
三、结语

---

     
一、媒介

   前面我们相识了构造和析构函数，今天让我们一探拷贝构造函数和赋值运算符重载的魅力吧。
  二、正文

1.拷贝构造函数

   

• 如果一个构造函数的第一个参数是自身类范例的引用，且任何额外的参数都有默认值，则此构造函数也叫做拷贝构造函数，也就是说拷贝构造是一个特别的构造函数。
  
• 拷贝构造的特点：
  

  

• 拷贝构造函数是构造函数的一个重载。
  
• 拷贝构造函数的第一个参数必须是类范例对象的引用，使用传值方式编译器直接报错，由于语法逻辑上会引发无穷递归调用。拷贝构造函数也可以多个参数，但是第一个参数必须是类范例对象的引用，后面的参数必须有缺省值。
  
• C++规定自定义范例对象举行拷贝举动必须调用拷贝构造，以是这里自定义范例传值传参和传值返回都会调用拷贝构造完成。
  
• 若未显式定义拷贝构造，编译器会天生自动天生拷贝构造函数。自动天生的拷贝构造对内置范例成员变量会完成值拷贝/浅拷贝（一个字节一个字节的拷贝），对自定义范例成员变量会调用他的拷贝构造。 
  
• 像Date这样的类成员变量全是内置范例且没有指向什么资源，编学器自动天生的拷贝构作育可以完成需要的拷贝。以是不需要我们显示实现拷贝构造。像Stack这样的类，虽然也都是内置范例，但是_a指向了资源， 编译器自动天生的拷贝构造完成的值拷贝/浅拷贝不符合我们的需求，以是需要我们本身实现深拷贝（对指向的资源也举行拷贝）。像MyQueue这样的范例内部重要是自定义范例stack成员，编译器自动天生的拷贝构造会调用Stack的拷贝构造，也不需要我们显示实现MyQueue的拷贝构造。这里另有一个小本事，如果一个类显示实现了析构并释放资源，那么他就需要显示写拷贝构造，否则就不需要。
  
• 传值返回会产生一个暂时对象调用拷贝构造，传值引用返回，返回的是返回对象的别名（引用），没有产生拷贝。但是如果返回对象是一个当前函数局部域的局部对象，函数结束就烧毁了，那么使用引用返回是有问题的，这时的引用相当于一个野引用，类似一个野指针一样。传引用返回可以减少拷贝，但是一定要确保返回对象，在当前函数结束后还在，才气用引用返回。
  

  1.1拷贝构造函数的使用

   

1. #include<iostream>
2. using namespace std;
3. class Date
4. {
5. public :
6.         Date(int year = 2024, int month = 11, int day = 18)
7.         {
8.                 _year = year;
9.                 _month = month;
10.                 _day = day;
11.         }
12.         Date( Date d)//这里会报错，因为拷贝构造函数必须使用传引用传参，否则会发生无限递归。
13.         {
14.                 _year = d._year;
15.                 _month = d._month;
16.                 _day = d._day;
17.         }
18. private:
19.         int _year;
20.         int _month;
21.         int _day;
22. };
23. int main()
24. {
25.         Date d1;
26.         Date d2(d1);//我们可以利用拷贝构造函数创建一摸一样的实例对象
27.         return 0;
28. }

复制代码

上面的拷贝构造函数Date（Date d）会发生无穷递归，这是由于拷贝构造函数的特点中：C++规定自定义范例对象举行拷贝举动必须调用拷贝构造，以是这里自定义范例传值传参和传值返回都会调用拷贝构造完成。如果我们本身写了拷贝构造函数，编译器会选择运行我们手写的拷贝构造函数，而不会再本身天生新的拷贝构造函数（如果我们没写，编译器会本身写一个拷贝构造函数实现浅拷贝）。
  这里我们写了Date（Date d）这一个没使用引用的错误拷贝构造函数，会发生无穷递归，如图所示：
  

  图画的有点潦草，很抱歉我比较手残。当我们想要通过拷贝构造函数将d1拷贝给d2的时候，由于每次调用拷贝构造函数之前要先传值传参，传值传参是一种拷贝，又形成一个新的拷贝构造，就形成了无穷递归。（d1拷贝给d2一份的过程中，d1传值传参给拷贝构造函数，调用拷贝构造函数，传值传参又会调用构造函数~）
  那么精确的拷贝构造函数该怎样誊写呢？
  

  如果我们不写拷贝构造函数，编译器会自动给我们天生拷贝拷贝构造函数吗？
  

  答案是肯定的，从上面这段代码我们可以看出，即使我们已经表明掉了我们本身手写的拷贝构造函数，但是d2还是成功拷贝了d1。以是我们说，即使我们不显示写拷贝构造函数，编译器依旧会帮助我们对对象举行浅拷贝。
  那么问题来了。什么是浅拷贝，什么是深拷贝呢？
  简单来说：浅拷贝就是没有类成员变量指向资源的简单值拷贝。而深拷贝就是类成员中存在指向资源的情况就是深拷贝（例如Stack中我们就需要用到深拷贝，由于由资源的申请与释放）

1. #include<iostream>
2. using namespace std;
3. typedef int STDataType;
4. class Stack
5. {
6. public:
7.         Stack(int n = 4)
8.         {
9.                 _a = (STDataType*)malloc(sizeof(STDataType) * n);
10.                 if (nullptr == _a)
11.                 {
12.                         perror("malloc 申请空间失败");
13.                         return;
14.                 }
15.                 _capacity = n;
16.                 _top = 0;
17.         }
18.         Stack(const Stack& st)
19.         {
20.                 _a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);//这里我们需要为拷贝的对象重新分配一块空间，是防止程序结束一块空间被连续析构两次，造成程序崩坏
21.                 if (nullptr == _a)
22.                 {
23.                         perror("malloc 申请空间失败");
24.                         return;
25.                 }
26.                 memcpy(_a, st._a, sizeof(STDataType) * st._top);
27.                 _top = st._top;
28.                 _capacity = st._capacity;
29.         }
30.         ~Stack()
31.         {
32.                 free(_a);
33.                 _a = nullptr;
34.                 _top = _capacity = 0;
35.         }
36. private:
37.         STDataType* _a;
38.         int _capacity;
39.         int _top;
40. };
41. int main()
42. {
43.         Stack sk1;
44.         Stack sk2(sk1);
45.         return 0;
46. }

复制代码

像上面Stack（const Stack& st）就是深拷贝，我们需要为拷贝的对象重新申请一块空间来保存这个对象中一些需要指向资源的成员（如这里的_a）。
  这里是不能举行浅拷贝的否则会造成一个空间被一连析构两次的问题。
  

  

  上面两个图是浅拷贝，只是无脑的将d1的capacity和top举行简单的值拷贝，将d1的_a所在赋值给d2（当我们不写拷贝构造函数的时候，编译器自动实现的就和我们上面写的一样，只能简单的实现浅拷贝）。这样当我们析构的时候，由于_a指向的资源需要释放，而d1和d2中的成员_a都指向这块空间，对一块空间一连释放两次很显着是不符合的。
  

  
1.2对于传引用返回的问题

  

1. #include<iostream>
2. using namespace std;
3. class Date
4. {
5. public :
6.         Date(int year = 2024, int month = 11, int day = 18)
7.         {
8.                 _year = year;
9.                 _month = month;
10.                 _day = day;
11.         }
12.         Date( const Date& d)//正确的是传引用传参，加入const修辞是防止有人不小心修改了我们的实参。
13.         {
14.                 _year = d._year;
15.                 _month = d._month;
16.                 _day = d._day;
17.         }
18.         void Print()
19.         {
20.                 cout << _year <<"-"<<_month<<"-"<<_day << endl;
21.         }
22. private:
23.         int _year;
24.         int _month;
25.         int _day;
26. };
27. Date& test()//当我们使用传引用返回的时候，记得一定要确保在当前函数结束后，该返回对象依旧存在否则会发生类似野指针一样的情况
28. {
29.         Date d3(2024, 11, 19);
30.         return d3;
31. }
32. int main()
33. {
34.         Date d1;
35.         Date d2(d1);
36.         Date d4 = test();
37.         d4.Print();
38.         return 0;
39. }

复制代码

 拷贝函数特点：传值返回会产生一个暂时对象调用拷贝构造，传值引用返回，返回的是返回对象的别名（引用），没有产生拷贝。但是如果返回对象是一个当前函数局部域的局部对象，函数结束就烧毁了，那么使用引用返回是有问题的，这时的引用相当于一个野引用，类似一个野指针一样。传引用返回可以减少拷贝，但是一定要确保返回对象，在当前函数结束后还在，才气用引用返回。
  就犹如上图一样，如果我们在test函数结束的时候，d3已经就烧毁了，那么返回给d4并打印的年月日将是随机值，而非2024-11-19。
  

  但是，如果我们这里使用传值返回呢？
  

  我们会发现输出的是精确的值，因此虽然传值引用返回，没有产生拷贝，但我们还需注意不要让返回的变量在该函数结束后就被烧毁了，导致返回的是野指针。是否使用传值还是传引用返回，还需我们本身斟酌。
  2.赋值运算符重载

2.1运算符重载

   

• 当运算符被用于类范例的对象时，C++语言允许我们通过运算符重载的形式指定新的寄义。C++规定类范例对象使用运算符时，必须转换成调用对应运算符重载，若没有对应的运算符重载，则会编译报错。
  
• 运算符重载是具有特别名字的函数，他的名字是由operator和后面要定义的运算符共同构成。和其他函数一样，它也具有其返回范例和参数列表以及函数体。
  
• 重载运算符函数的参数个数和该运算符作用的运算对象数目一样多。一元运算符有一个参数，二元运算符有两个参数，二元运算符的左侧运算对象传给第一个参数，右侧运算对象传给第二个参数。如果一个重载运算符函数是成员函数，则它的第一个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少一个。
  
• 运算符重载以后，其优先级和结合性与对应的内置范例运算符保持一致。
  
• 不能通过毗连语法中没有的符号来创建新的利用符：好比operator@。
  
• .*   ::    sizeof   ?:  .   注意以上5个运算符不能重载。（选择题内里常考，大家要记一下）
  
• 重载利用符至少有一个类范例参数，不能通过运算符重载改变内置范例对象的寄义，如：int operator+(int x, int y)
  
• 一个类需要重载哪些运算符，是看哪些运算符重载后有意义，好比Date类重载operato-就有意义，但是重载operator+就没有意义。（一个日期加一个日期是没有意义的）
  
• 重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，无法很好的区分。C++规定，后置++重载时，增长一个int形参，跟前置++构成函数重载，方便区分。
  
• 重载<<和>>时，需要重载为全局函数，由于重载为成员函数，this指针默认抢占了第一个形参位置，第一个形参位置是左侧运算对象，调用时就变成了对象<<cout，不符合使用习惯和可读性。重载为全局函数把ostream/istream放到第一个形参位置就可以了，第二个形参位置当类范例对象。
  

  2.1.1运算符重载的使用

  

1. #include<iostream>
2. using namespace std;
3. class Date
4. {
5. public :
6.         Date(int year = 2024, int month = 11, int day = 18)
7.         {
8.                 _year = year;
9.                 _month = month;
10.                 _day = day;
11.         }
12.         Date( const Date& d)//正确的是传引用传参，加入const修辞是防止有人不小心修改了我们的实参。
13.         {
14.                 _year = d._year;
15.                 _month = d._month;
16.                 _day = d._day;
17.         }
18.         void Print()
19.         {
20.                 cout << _year <<"-"<<_month<<"-"<<_day << endl;
21.         }
22. //private:
23.         int _year;
24.         int _month;
25.         int _day;
26. };
27. //把运算符重载定义在全局是最正宗的写法，但是我们需要访问类成员就需要将private内成员设置为public
28. //但是这是一种丢了西瓜，捡了芝麻的愚蠢行为。因为别人能修改我们的成员变量是一件很不安全的行为。
29. //那么我们如何在不将private内成员设置为public的前提下，正确实现运算符重载呢？
30. //1、成员设置为共有（上面我们已经说了，这种行为不可行）
31. //2、Date提供getxxx函数
32. //3、友元函数
33. //4、重载为成员函数（我们这章讲解的就是这种方法）
34. bool operator==(const Date& d1,const Date& d2)
35. {
36.         return d1._year == d2._year &&
37.                 d1._month == d2._month &&
38.                 d1._day == d2._day;
40. }
41. int main()
42. {
43.         Date d1(2024,11,18);
44.         Date d2(2024,11,19);
45.         d1 == d2;
46.         return 0;
47. }

复制代码

 为了在不让成员变量从私有（private）变为共有（public）的条件下实现运算符重载，我们可以接纳将运算符重载函数重载为成员函数的方法。

1. #include<iostream>
2. using namespace std;
3. class Date
4. {
5. public :
6.         Date(int year = 2024, int month = 11, int day = 18)
7.         {
8.                 _year = year;
9.                 _month = month;
10.                 _day = day;
11.         }
12.         Date( const Date& d)//正确的是传引用传参，加入const修辞是防止有人不小心修改了我们的实参。
13.         {
14.                 _year = d._year;
15.                 _month = d._month;
16.                 _day = d._day;
17.         }
18.         void Print()
19.         {
20.                 cout << _year <<"-"<<_month<<"-"<<_day << endl;
21.         }
22.         bool operator==(const Date& d)//成员函数的·第一个形参是隐式this，不会显示在形参中，所以显示的形参会比实际少一个
23.         {
24.                 return _year = +d._year &&
25.                         _month == d._month &&
26.                         _day == d._day;
27.         }
28. private:
29.         int _year;
30.         int _month;
31.         int _day;
32. };
33. int main()
34. {
35.         Date d1(2024,11,18);
36.         Date d2(2024,11,19);
37. //运算符重载下面两种方法都可以正常运行，当然方法一看起来顺眼一些。
38.         //1、d1 == d2;
39.     //2、d1.operator==(d2);
40.         return 0;
41. }

复制代码

  2.2赋值运算符重载

   赋值运算符重载是一个默认成员函数，用于完成两个已经存在的对象直接的拷贝赋值，这里要注意跟拷贝构造区分，拷贝构造用于一个对象拷贝初始化给另一个要创建的对象。
赋值运算符重载的特点：
  

• 赋值运算符重载是一个运算符重载，规定必须重载为成员函数。赋值运算重载的参数发起写成const 当前类范例引用，否则会传值传参会有拷贝
  
• 有返回值，且发起写成当前类范例引用，引用返回可以提高效率，有返回值目标是为了支持一连赋值场景。
  
• 没有显式实现时，编译器会自动天生一个默认赋值运算符重载，默认赋值运算符重载举动跟默认拷贝构造函数类似，对内置范例成员变量会完成值拷贝/浅拷贝（一个字节一个字节的拷贝），对自定义范例成员变量会调用他的赋值重载函数。 
  
• 像Date这样的类成员变量全是内置范例且没有指向什么资源，编译器自动天生的赋值运算符重载就可以完成需要的拷贝，以是不需要我们显示实现赋值运算符重载。像Stack这样的类，虽然也都是内置范例，但是_a指向了资源，编译器自动天生的赋值运算符重载完成的值拷贝/浅拷贝不符合我们的需求，以是需要我们本身实现深拷贝（对指向的资源也举行拷贝）。像MyQueue这样的范例内部重要是自定义范例Stack成员，编译器自动天生的赋值运算符重载会调用Stack的赋值运算符重载，也不需要我们显示实现MyQueue的赋值运算符重载。这里另有一个小本事，如果一个类显示实现了析构并释放资源，那么他就需要显示写赋值运算符重载，否则就不需要。
  

  2.2.1赋值运算符的使用

   

1. #include<iostream>
2. using namespace std;
3. class Date
4. {
5. public :
6.         Date(int year = 2024, int month = 11, int day = 18)
7.         {
8.                 _year = year;
9.                 _month = month;
10.                 _day = day;
11.         }
12.         Date( const Date& d)//正确的是传引用传参，加入const修辞是防止有人不小心修改了我们的实参。
13.         {
14.                 _year = d._year;
15.                 _month = d._month;
16.                 _day = d._day;
17.         }
18.         void Print()
19.         {
20.                 cout << _year <<"-"<<_month<<"-"<<_day << endl;
21.         }
22.         bool operator==(const Date& d)//成员函数的·第一个形参是隐式this，不会显示在形参中，所以显示的形参会比实际少一个
23.         {
24.                 return _year = +d._year &&
25.                         _month == d._month &&
26.                         _day == d._day;
27.         }
28.         Date& operator=(const Date& d)//这里使用传引用返回可以减少一次拷贝构造，当然也可以不用。（这里不使用传引用返回，不会发生无限递归）
29.         {
30.                 _year = d._year;
31.                 _month = d._month;
32.                 _day = d._day;
33.                 return *this;
34.         }
35. private:
36.         int _year;
37.         int _month;
38.         int _day;
39. };
40. int main()
41. {
42.         Date d1(2024,11,18);
43.         Date d2(2024,11,19);
44.         Date d3(2024, 11, 20);
45.         d1 = d2 = d3;
46.         return 0;
47. }

复制代码

  3.注意事项（构造函数和赋值运算符重载的误判） 

   构造函数是一个对象拷贝初始化给另一个要创建的对象。
  赋值运算符是两个已经存在的对象直接的拷贝赋值。
  

  三、结语

    今天的分享就结束了，让我们下期再见吧。拜拜~

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。