构造函数，拷贝构造函数，以及赋值操作调用的具体使用

一般会产生临时对象的三种情况：

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

  2，类型转换；

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

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

#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:
int GetSum(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的一个副本

return tmp;
}
//--------------Main函数-----------------
void main()
{
CTemp tm(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本身。
解决办法即将函数形参该为类的引用或指针类型。

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

 

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

void main()
{
CTemp tm(10,20),sum;
sum = 1000;  //调用CTemp(int m = 0,int n = 0)构造函数
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申明推迟到“=”号之前： 即，将CTemp sum ； sum = 1000 ， 由调用两次构造函数并进行赋值操作变成了类的初始化，而且只需要调用一次构造函数。

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的构造推迟了。当我们定义CTmep sum时，在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)
{
CTemp tmp;      //构建一个临时对象
tmp.a = ts.a*2;
return tmp;

}
//-------------Main函数-----------------
void main()
{
CTemp tm(10),sum;
printf("/n/n");
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

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

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

CTemp Double(CTemp& ts)
{
return ts.a*2;
}
/*--------上面的代码相当于-------
CTemp _ret
void Double(CTemp& ts)
{
_ret.a = ts.a*2;
}
---------------*/

//---------Main函数-----------
void main()
{
CTemp tm(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拷贝给返回对象)调用和一次赋值拷贝函数调用.(Assignment Copy Ctor),这是因为：

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

参考自：http://blog.csdn.net/happysujia/article/details/51298985