C++的临时对象

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

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

   2，类型转换；

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

   现在我们依次看这三种情况：
  一，以值的方式给函数传参。

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


#include <stdio.h>

class CTemp

{

public:

    int a;

    int b;

public:

   CTemp(CTemp& t){ printf("Copy function!\n");a =t.a;b = t.b;};

    CTemp(int m= 0,int n = 0);

    virtual~CTemp(){};

public:

    intGetSum(CTemp ts);

};

CTemp::CTemp(int m , int n)

{

   printf("Construct function!\n");

    a =m;b=n;

    printf("a =%d\n",a);

    printf("b =%d\n",b);

}

int CTemp::GetSum(CTemp ts)

{

    int tmp =ts.a + ts.b;

    ts.a =1000;          //此时修改的是tm的一个副本

    returntmp;

}

//--------------Main函数-----------------

void main()

{

    CTemptm(10,20);

    printf("Sum= %d \n",tm.GetSum(tm));

    printf("tm.a= %d \n",tm.a);

}

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

Output:

Construct function!

a = 10

b = 20

Copy function!

Sum = 30

tm.a = 10

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

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

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

   2，在GetSum函数体内对tm副本进行的修改并没有影响到tm本身。这一点和经典的swap函数很类似。

   解决办法：

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

{

    int tmp =ts.a + ts.b;

    ts.a =1000;    //此时通过ts这个引用参考(refer to)对象本身，

    returntmp;

}

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

Output:

Construct function!

a = 10

b = 20

Sum = 30

tm.a = 1000

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

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

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

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

{

 CTemp tm(10,20),sum;

 sum = 1000; 





 printf("Sum = %d \n",tm.GetSum(sum));

}

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

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申明推迟到“=”号之前：
void main()

{

 CTemp tm(10,20);

 CTemp sum = 1000;

 printf("Sum = %d \n",tm.GetSum(sum));

}

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

Output:

Construct function!

a = 10

b = 20

Construct function!

a = 1000

b = 0

Sum = 1000

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

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

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

   三，函数返回一个对象。

   当函数需要返回一个对象，他会在栈中创建一个临时对象，存储函数的返回值。看以下代码
#include<stdio.h>

class CTemp

{

public:

    int a;

public:

   CTemp(CTemp& t) //Copy Ctor!

    {

       printf("Copy Ctor!\n");

       a = t.a;

    };

   CTemp& operator=(CTemp& t)//Assignment Copy Ctor!

    {

       printf("Assignment Copy Ctor!\n");

       a = t.a;

       return *this;

    }

    CTemp(int m= 0);

    virtual~CTemp(){};

};

CTemp::CTemp(int m) //Copy Ctor!

{

   printf("Construct function!\n");

    a = m;

    printf("a =%d\n",a);

}

CTemp Double(CTemp& ts)

{

    CTemptmp;     //构建一个临时对象

    tmp.a =ts.a*2;

    returntmp;

   

}

//-------------Main函数-----------------

void main()

{

    CTemptm(10),sum;

   printf("\n\n");
4000

    sum =Double(tm);

   

   printf("\n\nsum.a = %d \n",sum.a);

}

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

Output:

Construct function!

a = 10

Construct function!

a = 0

Construct function!

a = 0

Copy Ctor!

Assignment Copy Ctor!

sum.a = 20

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

    我特地加宽了语句:

    sum =Double(tm);

   这条语句竟生成了两个对象，Horrible! 我们现在将这条语句逐步分解一下：

   1,我们显式创建一个tmp临时对象,               

     语句：CTemp tmp;

   2,将temp对象返回，返回过程中调用Copycotr创建一个返回对象,             

     语句：return tmp;

   3,将返回结果通过调用赋值拷贝函数,赋给sum       

     语句: sum = 函数返回值;(该步并没有创建对象，只是给sum赋值)

   tm.Double返回一个用拷贝构造函数生成的临时对象，并用该临时对象给sum赋值.

   上面的第1步创建对象可以不用创建，我们可以直接对返回值进行操作，有些C++编译器中会有一种优化，叫做(NRV,named returnvalue).不过本人使用的VC++6.0并没有这个启用这个优化。

   第2步创建的返回对象是难以避免的，你或许想可以返回一个引用，但你别忘记了在函数里创建的局部对象，在返回时就被销毁了。这时若再引用该对象会产生未预期的行为。(C#中解决了这个问题)。
解决方法：

 我们将对象直接操作(Manipulate)返回对象,再结合上面的减少临时对象的方法，将函数Double的代码，及main函数中的代码修改如下：
CTemp Double(CTemp&ts)

{

    returnts.a*2;

}





//---------Main函数-----------

void main()

{

    CTemptm(10);

   printf("\n\n");

   CTemp sum = Double(tm);

   

   printf("\n\nsum.a = %d \n",sum.a);

}

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

Output:

Construct function!

a = 10

Construct function!

a = 20

sum.a = 20

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

   发现减少了一次构造函数调用(tmp)，一次拷贝构造函数(tmp拷贝给返回对象)调用和一次赋值拷贝函数调用.(AssignmentCopy Ctor),这是因为：

    返回对象直接使用为sum预留的空间，所以减少了返回临时对象的生成——返回对象即是sum，返回对象的创建即是sum对象的创建.多么精妙!