C++中的赋值运算符重载函数(operator=)

本文主要介绍C++中的赋值运算符重载函数(operator=)的相关知识。

1. 概述

1.1 why

首先介绍为什么要对赋值运算符“=”进行重载。某些情况下,当我们编写一个类的时候,,并不需要为该类重载“=”运算符,因为编译系统为每个类提供了默认的赋值运算符“=”,使用这个默认的赋值运算符操作类对象时,该运算符会把这个类的所有数据成员都进行一次赋值操作。例如有如下类:


 
 
  1. class A
  2. {
  3. public:
  4. int a;
  5. int b;
  6. int c;
  7. };

那么对这个类的对象进行赋值时,使用默认的赋值运算符是没有问题的。示例代码(operator_test4.cpp)如下:


 
 
  1. #include <iostream>
  2. using namespace std;
  3. class ClassA
  4. {
  5. public:
  6.     int a;
  7.     int b;
  8.     int c;
  9. };
  10. int main()
  11. {
  12.     ClassA obj1;
  13.     obj1.a = 1;
  14.     obj1.b = 2;
  15.     obj1.c = 3;
  16.     ClassA obj2;
  17.     obj2 = obj1;
  18.     cout << "obj2.a is: " << obj2.a << endl;
  19.     return 0;
  20. }

编译并执行上述代码,结果如下:

从上述结果能够知道:通过使用系统默认的赋值运算符“=”,可以让对象obj2中的所有数据成员的值与对象obj1相同。这种情况下,编译系统提供的默认赋值运算符可以正常使用。

但是,在下面的示例中,使用编译系统默认提供的赋值运算符,就会出现问题了。示例代码(operator_test5.cpp)如下:


 
 
  1. #include <iostream>
  2. #include <string.h>
  3. using namespace std;
  4. class ClassA
  5. {
  6. public:
  7. ClassA()
  8. {
  9. }
  10. ClassA( const char* pszInputStr)
  11. {
  12. pszTestStr = new char[ strlen(pszInputStr) + 1];
  13. strncpy(pszTestStr, pszInputStr, strlen(pszInputStr) + 1);
  14. }
  15. virtual ~ClassA()
  16. {
  17. delete pszTestStr;
  18. }
  19. public:
  20. char* pszTestStr;
  21. };
  22. int main()
  23. {
  24. ClassA obj1("liitdar");
  25. ClassA obj2;
  26. obj2 = obj1;
  27. cout << "obj2.pszTestStr is: " << obj2.pszTestStr << endl;
  28. cout << "addr(obj1.pszTestStr) is: " << &obj1.pszTestStr << endl;
  29. cout << "addr(obj2.pszTestStr) is: " << &obj2.pszTestStr << endl;
  30. return 0;
  31. }

编译并运行上述代码,结果如下:

上述错误信息说明:当obj1和obj2进行析构的时候,由于重复释放了一块内存,导致程序崩溃报错。在这种情况下,就需要我们重载赋值运算符“=”了。

2. 示例代码

 

2.1 示例代码1

我们修改一下前面出错的代码示例,现编写一个包含赋值运算符重载函数的类,代码(operator_test5.cpp)如下:


 
 
  1. #include <iostream>
  2. #include <string.h>
  3. using namespace std;
  4. class ClassA
  5. {
  6. public:
  7. ClassA()
  8. {
  9. }
  10. ClassA( const char* pszInputStr)
  11. {
  12. pszTestStr = new char[ strlen(pszInputStr) + 1];
  13. strncpy(pszTestStr, pszInputStr, strlen(pszInputStr) + 1);
  14. }
  15. virtual ~ClassA()
  16. {
  17. delete pszTestStr;
  18. }
  19. // 赋值运算符重载函数
  20. ClassA& operator=( const ClassA& cls)
  21. {
  22. // 避免自赋值
  23. if ( this != &cls)
  24. {
  25. // 避免内存泄露
  26. if (pszTestStr != NULL)
  27. {
  28. delete pszTestStr;
  29. pszTestStr = NULL;
  30. }
  31. pszTestStr = new char[ strlen(cls.pszTestStr) + 1];
  32. strncpy(pszTestStr, cls.pszTestStr, strlen(cls.pszTestStr) + 1);
  33. }
  34. return * this;
  35. }
  36. public:
  37. char* pszTestStr;
  38. };
  39. int main()
  40. {
  41. ClassA obj1("liitdar");
  42. ClassA obj2;
  43. obj2 = obj1;
  44. cout << "obj2.pszTestStr is: " << obj2.pszTestStr << endl;
  45. cout << "addr(obj1.pszTestStr) is: " << &obj1.pszTestStr << endl;
  46. cout << "addr(obj2.pszTestStr) is: " << &obj2.pszTestStr << endl;
  47. return 0;
  48. }

编译并运行上述代码,结果如下:

通过上述结果能够看到,我们利用赋值运算符重载函数,解决了对象赋值的情况下,析构函数中过程中多次释放同一块内存的问题。

对于上述代码,有以下几点需要说明:

 

  • 当为一个类的对象赋值(可以用本类对象为其赋值,也可以用其它类型的值为其赋值)时,该对象(如本例的obj2)会调用该类的赋值运算符重载函数,进行具体的赋值操作。如上述代码中的“obj2 = obj1;”语句,用obj1为obj2赋值,则会由obj2调用ClassA类的赋值运算符重载函数。
  • 语句“ClassA obj2;
              obj2 = obj1;“
    和语句“ClassA obj2 = obj1;”在调用函数上是有区别的:前者第一句是对象obj2的声明及定义,调用类ClassA的无参构造函数,所以“obj2 = obj1;”一句是在对象obj2已经存在的情况下,用obj1来为obj2赋值,调用的是赋值运算符重载函数;而后者,是用obj1来初始化obj2,调用的是拷贝构造函数。关于拷贝构造函数的语句样式为“ClassA(const ClassA& cls)”,关于拷贝构造函数的内容,此处不进行详述。
  • 当程序没有显式地提供一个以“本类或本类的引用”为参数的赋值运算符重载函数时,编译器会自动生成一个默认的赋值运算符重载函数。

 

2.2 示例代码2

示例代码(operator_test6.cpp)如下:


 
 
  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  4. class Data
  5. {
  6. private:
  7. int data;
  8. public:
  9. // 构造函数
  10. Data()
  11. {
  12. };
  13. // 构造函数
  14. Data( int _data):data(_data)
  15. {
  16. cout << "This is constructor" << endl;
  17. }
  18. // 赋值运算符重载函数
  19. Data& operator=( const int _data)
  20. {
  21. cout << "This is operator=(int _data)" << endl;
  22. data = _data;
  23. return * this;
  24. }
  25. };
  26. int main()
  27. {
  28. // 调用构造函数
  29. Data data1(1);
  30. Data data2, data3;
  31. // 调用赋值运算符重载函数
  32. data2 = 1;
  33. // 调用默认的赋值运算符重载函数
  34. data3 = data2;
  35. return 0;
  36. }

编译并执行上述代码,结果如下:

上述结果说明:“data2 = 1;”语句调用了我们提供的以int型参数(而非本类或本类的引用)为形参的赋值运算符重载函数,而“data3 = data2;”的成功执行,说明该语句调用了编译器提供的默认的赋值运算符重载函数。

如果将上述代码中赋值运算符重载函数去掉,重新编译执行,结果如下:

 

上述结果说明,当用一个非类A的值(如上面的int类型值)为类A的对象赋值时:

 

  • 如果检测到构造函数和赋值运算符重载函数同时存在,则会调用赋值运算符重载函数;
  • 如果检测到的构造函数,就会调用这个构造函数。

3. 总结

综合上述示例内容,我们可以知道针对以下情况,需要显式地提供赋值运算符重载函数(即自定义赋值运算符重载函数):

 

  • 用非类A类型的值为类A的对象赋值时(当然,这种情况下我们可以不提供相应的赋值运算符重载函数,而只提供相应的构造函数,如更改后的示例代码2)。
  • 当用类A类型的值为类A的对象赋值,且类A的数据成员中含有指针的情况下,必须显式提供赋值运算符重载函数(如示例代码1)。
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值