C++中的临时对象（拷贝构造函数）（上）

我们知道在C++的创建对象是一个费时，费空间的一个操作。有些固然是必不可少，但还有一些对象却在我们不知道的情况下被创建了。通常以下三种情况会产生临时对象：

  1，以值的方式给函数传参；

  2，类型转换；

  3，函数需要返回一个对象时；

 

现在我们依次看这三种情况：

 

   一，以值的方式给函数传参。

 

  我们知道给函数传参有两种方式。1，按值传递；2，按引用传递。按值传递时，首先将需要传给函数的参数，调用拷贝构造函数创建一个副本，所有在函数里的操作都是针对这个副本的，也正是因为这个原因，在函数体里对该副本进行任何操作，都不会影响原参数。我们看以下例子：

view plain

1. #include <stdio.h>  
2. class CTemp  
3. {  
4. public:  
5.     int a;  
6.     int b;  
7. public:  
8.     CTemp(CTemp& t){ printf("Copy function!/n");a = t.a;b = t.b;};  
9.     CTemp(int m = 0,int n = 0);  
10.     virtual ~CTemp(){};  
11. public:  
12.     int GetSum(CTemp ts);  
13. };  
14. CTemp::CTemp(int m , int n)  
15. {  
16.     printf("Construct function!/n");  
17.     a = m;b=n;  
18.     printf("a = %d/n",a);  
19.     printf("b = %d/n",b);  
20. }  
21. int CTemp::GetSum(CTemp ts)  
22. {  
23.     int tmp = ts.a + ts.b;  
24.     ts.a = 1000;           //此时修改的是tm的一个副本  
25.       
26.     return tmp;  
27. }  
28. //--------------Main函数-----------------  
29. void main()  
30. {  
31.     CTemp tm(10,20);  
32.     printf("Sum = %d /n",tm.GetSum(tm));  
33.     printf("tm.a = %d /n",tm.a);  
34. }  

--------------------------------------------------------

Output:

Construct function!
a = 10
b = 20
Copy function!
Sum = 30
tm.a = 10

------------------------------------------------------

我们看到有调用了拷贝构造函数，这是tm在传给GetSum做参数时：

1，调用拷贝构造函数来创建一个副本为GetSum函数体内所用。

2，在GetSum函数体内对tm副本进行的修改并没有影响到tm本身。

 

解决办法：

  针对第一种情况的解决办法是传入对象引用( 记住：引用只是原对象的一个别名(Alias))， 我们将GetSum代码修改如下：

view plain

1. int CTemp::GetSum(CTemp& ts)  
2. {  
3.     int tmp = ts.a + ts.b;  
4.     ts.a = 1000;     //此时通过ts这个引用参考(refer to)对象本身  
5.     return tmp;  
6. }  

----------------------------------------------------------

Output:

Construct function!
a = 10
b = 20
Sum = 30
tm.a = 1000

--------------------------------------------------------

可以通过输出看本，通过传递常量引用，减少了一次临时对象的创建。这个改动也许很小，但对多继承的对象来说在构建时要递归调用所有基类的构造函数，这对于性能来说是个很大的消耗，而且这种消耗通常来说是没有必要的。

 

   二，类型转换生成的临时对象。

 

  我们在做类型转换时，转换后的对象通常是一个临时对象。编译器为了通过编译会创建一起我们不易察觉的临时对象。再次修改如上main代码：

view plain

1. void main()  
2. {  
3.  CTemp tm(10,20),sum;  
4.  sum = 1000;  //调用CTemp(int m = 0,int n = 0)构造函数  
5.  printf("Sum = %d /n",tm.GetSum(sum));  
6. }  

-----------------------------------------------------------

Output:

Construct function!
a = 10
b = 20
Construct function!
a = 0
b = 0
Construct function!
a = 1000
b = 0 
Sum = 1000

----------------------------------------------------------

main函数创建了两个对象，但输出却调用了三次构造函数，这是为什么呢？

关键在 sum = 1000;这段代码。本身1000和sum类型不符，但编译器为了通过编译以1000为参调用构造函数创建了一下临时对象。

 

解决办法 ：

  我们对main函数中的代码稍作修改，将sum申明推迟到“=”号之前：

view plain

1. void main()  
2. {  
3.  CTemp tm(10,20);  
4.  CTemp sum = 1000;  
5.  printf("Sum = %d /n",tm.GetSum(sum));  
6. }  

----------------------------------------------------------

Output:

Construct function!
a = 10
b = 20
Construct function!
a = 1000 
b = 0
Sum = 1000

----------------------------------------------------------

只作了稍稍改动，就减少了一次临时对象的创建。

1，此时的“=”号由原本的赋值变为了构造。

2，对Sum的构造推迟了。当我们定义CTmep sum时，在main的栈中为sum对象创建了一个预留的空间。而我们用1000调用构造时，此时的构造是在为sum预留的空间中进行的。因此也减少了一次临时对象的创建。

转自：http://blogold.chinaunix.net/u2/74578/showart_2323518.html