033-C++之运算符重载2

moc

1、重载= 内存泄露场景
类中有挂了内存块的指针成员，在使用下面的=重载时，会造成内存泄露，十分隐蔽。

1. void operator=(name &obj)
   
2. {
   
3.         char *pn = obj.GetPn();  
   
4.         //if (pname != NULL)  delete[] pname;  //如果没有此句，会造成内存泄漏
   
5.         pname = new char[strlen(pn) + 1];
   
6.         if (pname != NULL)  strcopy(pname, pn);
   
7.         // delete[] pn;     
   
8.         size = strlen(pn);
   
9. }

复制代码

2、[]  =  ==  !=   操作符的重载
使用 .h 和 .cpp 类的定义和实现 分离的方式完成上述操作符的重载，以及测试。
Array.h

1. #pragma once
   
2. 
   
3. class Array
   
4. {
   
5. private:
   
6.         int mLength;
   
7.         int* mSpace;
   
8. 
   
9. public:
   
10.         Array(int length);
    
11.         Array(const Array& obj);
    
12.         int length();
    
13.         void setData(int index, int value);
    
14.         int getData(int index);
    
15.         ~Array();
    
16. 
    
17. // []  =  ==  !=   项目中的难点
    
18.         int& operator[](int i);         // [] 重载
    
19.         Array& operator=(Array &a2);    // = 重载
    
20.         bool operator==(Array &a2);     // == 重载
    
21.         bool operator!=(Array &a2);     // != 重载
    
22. 
    
23. };

复制代码

Arraycpp.cpp

1. #include "iostream"
   
2. #include "Array.h"
   
3. using namespace std;
   
4. 
   
5. Array::Array(int length)
   
6. {
   
7.         if (length < 0)
   
8.         {
   
9.                 length = 0;
   
10.         }
    
11.         mLength = length;
    
12.         mSpace = new int[mLength];
    
13. }
    
14. 
    
15. Array::Array(const Array& obj)
    
16. {
    
17.         mLength = obj.mLength;
    
18.         mSpace = new int[mLength];
    
19. 
    
20.         for (int i = 0; i < mLength; i++)
    
21.         {
    
22.                 mSpace[i] = obj.mSpace[i];
    
23.         }
    
24. }
    
25. 
    
26. int Array::length()
    
27. {
    
28.         return mLength;
    
29. }
    
30. 
    
31. void Array::setData(int index, int value)
    
32. {
    
33.         mSpace[index] = value;
    
34. }
    
35. 
    
36. int Array::getData(int index)
    
37. {
    
38.         return mSpace[index];
    
39. }
    
40. 
    
41. Array::~Array()
    
42. {
    
43.         mLength = -1;
    
44.         delete[] mSpace;
    
45. }
    
46. 
    
47. // [] 重载的实现     // 为了实现返回值当左值，需要返回应用
    
48. int& Array::operator[](int i)
    
49. {
    
50.         return mSpace[i];
    
51. }
    
52. 
    
53. //Array a3(100);
    
54. //a3 = a2;        // = 重载
    
55. // 1) 如果a3已经分配内存则需要释放
    
56. // 2) 根据a2开辟内存空间 把a2的值copy到a3中
    
57. Array& Array::operator=(Array &a2)     // 如果返回值不加引用，这里会多执行一次copy构造函数创建一个匿名对象， 场景4
    
58. {                                      // 需要返回值当左值，必须返回一个引用
    
59.         if (this->mSpace != NULL)
    
60.         {
    
61.                 delete[] mSpace;
    
62.                 mSpace = NULL;
    
63.                 mLength = 0;
    
64.         }
    
65.         this->mLength = a2.mLength;
    
66.         this->mSpace = new int[this->mLength];
    
67. 
    
68.         for (int i = 0; i < this->mLength; i++)
    
69.         {
    
70.                 mSpace[i] = a2[i];
    
71.         }
    
72.         return *this;
    
73. }
    
74. 
    
75. // == 重载
    
76. bool Array::operator==(Array &a2)
    
77. {
    
78.         // 先判断a1和a2的长度是否相等
    
79.         // a1,a2中每个元素是否相等
    
80.         if (this->mLength != a2.mLength)
    
81.         {
    
82.                 return false;
    
83.         }
    
84. 
    
85.         for (int i = 0; i < this->mLength; i++)
    
86.         {
    
87.                 if (this->mSpace[i] != a2[i])
    
88.                 {
    
89.                         return false;
    
90.                 }
    
91.         }
    
92.         return true;
    
93. }
    
94. 
    
95. bool Array::operator!= (Array &a2)
    
96. {
    
97.         return !(*this==a2);  // 运算符重载也是一个函数
    
98. 
    
99. }

复制代码

测试：ArrayTest.cpp

1. #include "iostream"
   
2. #include "Array.h"
   
3. using namespace std;
   
4. 
   
5. int main()
   
6. {
   
7.         Array a1(10), a3(10);
   
8. 
   
9.         for (int i = 0; i < a1.length(); i++)
   
10.         {
    
11.                 //a1.setData(i, i);         // 想换成 a1[i] = i(函数返回值做左值)     [] 重载
    
12.                 // int& operator[](int i)   // 函数返回值做左值 ===>   需要函数返回引用
    
13.                 a1[i] = i;              
    
14.         }
    
15. 
    
16.         for (int i = 0; i < a1.length(); i++)
    
17.         {
    
18.                 //printf("array %d: %d \n", i, a1.getData(i));
    
19.                 cout << a1[i] << endl;
    
20.         }
    
21. 
    
22.         Array a2 = a1;   // 初始化 执行拷贝构造函数
    
23. 
    
24.         for (int i = 0; i < a2.length(); i++)
    
25.         {
    
26.                 printf("array %d: %d \n", i, a2.getData(i));
    
27.         }
    
28. 
    
29.         if (a2 == a1)     // == 重载
    
30.         {
    
31.                 printf("相等\n");
    
32.         }
    
33. 
    
34.         if (a3 != a1)     // == 重载
    
35.         {
    
36.                 printf("不相等\n");
    
37.         }
    
38. 
    
39.         Array a4(100);
    
40.         // 连等操作
    
41.         a1 = a4 = a2;      // = 重载   （函数返回值做左值）
    
42.         //a1.operator=(a3,operator=(a2));  与上面的语句等同
    
43. 
    
44.         system("pause");
    
45.         return 0;
    
46. }

复制代码