[已解决]C++重载赋值运算符的一点疑问

yuanming1027

1. class Na {
   
2. public:
   
3.     int *age;
   
4. 
   
5.     Na(int a) {
   
6.         age = new int(a);
   
7.     }
   
8. 
   
9. 
   
10.     Na& operator=(Na dy) {
    
11.         if (age != NULL) {
    
12.             delete age;
    
13.             age = NULL;
    
14.         };
    
15. 
    
16.         age = new int(*dy.age);
    
17.         return *this;
    
18.     }
    
19. 
    
20.     ~Na() {
    
21.         if (age != NULL) {
    
22.             delete age;
    
23.             age = NULL;
    
24.         }
    
25.     }
    
26. };
    
27. 
    
28. 
    
29. 
    
30. int main() {
    
31.     Na a1(10);
    
32.     Na a2(20);
    
33. 
    
34.     a1 = a2;
    
35.     cout << *a1.age << endl;
    
36.     cout << *a2.age << endl;
    
37.    
    
38.     system("pause");
    
39. 
    
40.     return 0;
    
41. }
    
42. 
    

复制代码

此代码是重载赋值运算符，用深拷贝解决浅拷贝带来的重复释放堆区数据。

如果重载函数的参数带上&，则输出正常为20.
如果不带&，则a2.age是负数，a1.age正常为20.
为什么a2.age是负数？

最佳答案

月排行榜 / 总排行榜

dolly_yos2

2022-9-14 16:14:47

把您的析构函数做了一点调整（加了一行辅助输出），您看看修改后的两种情况下的运行输出有什么区别，应该能给您一些启发。

1. ~Na() {
   
2.     if (age != NULL) {
   
3.         cout << "non-trivial destructor invocation\n";
   
4.         delete age;
   
5.         age = NULL;
   
6.     }
   
7. }

复制代码

跳转到最佳答案楼层

编程追风梦

没听懂你到底要问什么

yuanming1027

编程追风梦 发表于 2022-9-14 14:02
没听懂你到底要问什么

为什么重载赋值运算符的参数不带&，a2.age输出的是负数

jhq999

把引用&去掉也都是20，难道与编译器有关系？

dolly_yos2

把您的析构函数做了一点调整（加了一行辅助输出），您看看修改后的两种情况下的运行输出有什么区别，应该能给您一些启发。

1. ~Na() {
   
2.     if (age != NULL) {
   
3.         cout << "non-trivial destructor invocation\n";
   
4.         delete age;
   
5.         age = NULL;
   
6.     }
   
7. }

复制代码

yuanming1027

dolly_yos2 发表于 2022-9-14 16:14
把您的析构函数做了一点调整（加了一行辅助输出），您看看修改后的两种情况下的运行输出有什么区别，应该能 ...

666

yuanming1027

jhq999 发表于 2022-9-14 14:37
把引用&去掉也都是20，难道与编译器有关系？

不是返回值类型的&，是参数里面的&。这个疑问已经解决了

yuanming1027

dolly_yos2 发表于 2022-9-14 16:14
把您的析构函数做了一点调整（加了一行辅助输出），您看看修改后的两种情况下的运行输出有什么区别，应该能 ...

他为什么会调用析构函数呢？

dolly_yos2

yuanming1027 发表于 2022-9-14 19:58
他为什么会调用析构函数呢？

我的理解是这样的，当不加 & 的时候，赋值运算符的右操作数被按值传递进入重载的赋值函数，即复制为一个新的 Na 类型实例，这个新的实例中指针的值与右操作数一致，因此赋值可以正确的更新左操作数的值，但这个复制得到的新实例的生命周期在重载运算符方法调用完毕前结束，因此将会调用这个临时实例的析构函数导致右操作数内的指针被释放。
这一过程应该可以通过下面的代码进行直观观察

1. #include <iostream>
   
2. using namespace std;
   
3. class Na {
   
4. public:
   
5.     int *age;
   
6. 
   
7.     Na(int a) {
   
8.         age = new int(a);
   
9.     }
   
10. 
    
11. 
    
12.     Na& operator=(Na dy) {
    
13.         cout << "dy: " << addressof(dy) << endl;
    
14.         if (age != NULL) {
    
15.             delete age;
    
16.             age = NULL;
    
17.         };
    
18. 
    
19.         age = new int(*dy.age);
    
20.         return *this;
    
21.     }
    
22. 
    
23.     ~Na() {
    
24.         if (age != NULL) {
    
25.             cout << "non-trivial destructor invocation for " << this << endl;
    
26.             delete age;
    
27.             age = NULL;
    
28.         }
    
29.     }
    
30. };
    
31. 
    
32. 
    
33. 
    
34. int main() {
    
35.     Na a1(10);
    
36.     Na a2(20);
    
37.     cout << "a1: " << addressof(a1) << endl;
    
38.     cout << "a2: " << addressof(a2) << endl;
    
39. 
    
40.     a1 = a2;
    
41.     cout << *a1.age << endl;
    
42.     cout << *a2.age << endl;
    
43. 
    
44.     return 0;
    
45. }

复制代码