C++愤恨者札记5

临时变量的内存分配

这里考虑对象做为函数参数与返回值时，使用无名临时变量的情况。

临时变量内存分配

[cpp] view plaincopy

1. class Node  
2. {  
3.         public:  
4.             int data1;  
5.             int data2;  
6.             int data3;  
7.             Node()  
8.             {__asm nop}  
9. };  
10.   
11. void Fn1( Node n )  
12. {  
13.         n.data1++;  
14. }  
15.   
16. Node Fn2()  
17. {  
18.         return Node();  
19. }  
20.   
21. void main()  
22. {  
23.         __asm int 3  
24.         Fn1( Node() );  
25.         __asm int 3  
26.         Fn2();  
27.         __asm int 3  
28. }  

调用Fn1时的反汇编结果：

Fn2相关反汇编结果：

结论是：临时变量的内存来自于函数的调用者

修改临时变量的值

Fn1的参数并不是临时变量本身，而是由临时变量填充，在Fn1内部无法对其变量。而Fn2传入的是临时变量指针，可以在Fn2内外对其进行修改，下面是实验代码：

[cpp] view plaincopy

1. static int gTemp = 0;  
2. class Node  
3. {  
4.         public:  
5.             int data;  
6.             Node()  
7.             {  
8.                     if ( 0 == gTemp )  
9.                     {  
10.                             this->data = 0;  
11.                             gTemp++;  
12.                     }  
13.                     else  
14.                             this->data++;  
15.             }  
16. };  
17.   
18. Node Fn2()  
19. {  
20.         return Node();  
21. }  
22.   
23. void main()  
24. {  
25.         Node* p = 0;  
26.         __asm int 3  
27.         while ( true )  
28.         {  
29.                 p = &Fn2();  
30.                 p->data++;  
31.         }  
32.         __asm int 3  
33. }