目录
有些临时对象是系统自己产生的，又有一些临时对象却是因为代码的书写问题而产生的，因为临时对象会额外消耗系统资源，所以编写代码的原则就是产生的临时对象越少越好。临时对象一般都是在栈上，所以一般都不会手动去释放。
为什么要了解临时对象？因为临时对象的产生和销毁都是有成本的，都会影响程序的执行性能和效率，所以如果能有效地减少临时对象的产生，那么无疑意味着程序性能和效率的提升。
一、产生临时对象的情况
1.1 以值的方式给函数传递参数 - 如何优化呢
先看如下案例：
class CTempValue
{
public:
int val1;
int val2;
public:
//构造函数
CTempValue(int v1 = 0, int v2 = 0)
{
cout << "调用构造函数" << endl;
val1 = v1;
val2 = v2;
cout << "val1 = " << val1 << endl;
cout << "val2 = " << val2 << endl;
}
~CTempValue()
{
cout << "调用了析构函数" << endl;
}
//拷贝构造函数
CTempValue(const CTempValue& t)
{
cout << "调用拷贝构造函数" << endl;
val1 = t.val1;
val2 = t.val2;
cout << "val1 = " << val1 << endl;
cout << "val2 = " << val2 << endl;
}
int Add(CTempValue tobj)
{
int tmp = tobj.val1 + tobj.val2;
tobj.val1 = 1000; //这里的修改对外界没有影响
return tmp;
}
};
int main()
{
CTempValue tm(10, 20); //调用构造函数
int Sum = tm.Add(tm); // 这会调用拷贝构造函数的执行
cout << "Sum = " << Sum << endl; //Sum = 30
cout << "tm.val1 = " << tm.val1 << endl; //tm.val1 = 10
return 0;
}
运行结果如下：
调用构造函数
调用拷贝构造函数
调用了析构函数
Sum = 30
tm.val1 = 10
调用了析构函数
请注意，结果中调用了拷贝构造函数，为什么调用CTempValue类的拷贝构造函数呢？
这是因为调用Add成员函数时把对象tm传递给了Add成员函数，此时，系统会调用拷贝构造函数创建一个副本tobj（成员函数Add的形参），用于在函数体Add内使用，因为tm对象的vall值（tm对象的vall值仍旧为10）。
形参tobj是一个局部对象（局部变量），从程序功能的角度来讲，函数体内需要临时使用它一下，来完成一个程序上的一个功能，它确实是一个局部变量，只能在Add函数体里使用。所以严格意义来讲，它又不能称为一个真正意义的临时对象，因为真正的临时对象往往指的是真实存在，但又感觉不到的对象（至少从代码上不能直接看到的对象）。
但是，对于目前确实生成了tobj对象，并且调用了类的拷贝构造函数，有了复制的动作，就会影响程序的执行效率。
那如何优化呢？
我们可以使用引用：
int Add(CTempValue& tobj){}
1.2 类型转换生成的临时对象 - 如何优化呢
1.2.1 类型转换生成的临时对象
接下来，我们看下真正意义的临时对象，因为这个临时对象确实存在，但是从程序代码的角度不能直接看到它。
CTempValue sum; sum = 1000;
执行一下，程序结果如下：
调用构造函数
val1 = 0
val2 = 0
调用构造函数
val1 = 1000
val2 = 0
调用了析构函数
调用了析构函数
在执行sum = 1000;系统调用了一次CTempValue类的构造函数和析构函数，这说明系统肯定产生了一个对象，但这个对象在哪里，通过代码完全看不到，所以这个对象是一个真正的临时对象。
那么，产生这个临时对象的原因是什么呢？
是因为把1000赋给sum，而sum本身是一个CTempValue类型的对象，1000是一个数字，那怎么把数字能转化成CTempValue类型的对象呢？所以编译器这里帮助我们以1000为参数调用了CTempValue的构造函数创建了一个临时对象，因为CTempValue构造函数的两个参数都有默认值，所以这里的数字1000就顶替了第一个参数，而第二个参数系统就用了默认值，所以从1000是可以成功创建出CTempValue对象的。
为了进一步观察，增加拷贝赋值运算符的代码：
CTempValue& operator=(const CTempValue& tmpv)
{
cout << "调用了拷贝赋值运算符" << endl;
val1 = tmpv.val1;
val2 = tmpv.val2;
cout << "val1 = " << val1 << endl;
cout << "val2 = " << val2 << endl;
return *this;
}
执行程序，看下结果：
调用构造函数
val1 = 0
val2 = 0
调用构造函数
val1 = 1000
val2 = 0
调用了拷贝赋值运算符
val1 = 1000
val2 = 0
调用了析构函数
调用了析构函数
总结sum = 1000;这行代码系统做了哪些事：
用1000这个数字创建了一个类型为CTempValue的临时对象；调用拷贝赋值运算符把这个临时对象里面的各个成员值赋给了sum对象；销毁这个刚刚创建的CTempValue临时对象。
那如何优化呢？
可以把main主函数中刚刚写的两行代码优化成下面一行：
CTempValue sum = 1000; //" = " 在这里不是赋值运算符，而是定义初始化的概念
运行结果如下：
调用构造函数
val1 = 1000
val2 = 0
调用了析构函数
可以看到，系统没有生成临时对象，所以系统少调用了一次构造函数，少调用了一次拷贝赋值运算符、少调用了一次析构函数。
1.2.2 隐式类型转换以保证函数调用成功
int calc(const string& strsource, char ch)
{
const char * p = strsource.c_str();
int icount = 0;
//......具体的统计代码
return icount;
}
//在main主函数的代码如下：
int main()
{
char mystr[100] = "I love China, oh, yeah!";
int result = calc(mystr, 'o');
return 0;
}
一个是char数组，一个是const string&，但是这个函数就能调用成功，为什么呢？
当然是编译器帮助我们做了一些事情，解决类型不匹配，那是如何做的呢？
那就是编译器产生了一个类型sring的临时对象，这个临时对象的构造方式就是用mystr作为参数，调用了string的构造函数，这样形参strsoutce就绑定到这个string临时对象上了。当calc函数返回的时候，这个临时对象会被自动销毁。
C++只会为const string&(const引用)产生临时对象，不会为string&(非const)产生临时对象。
1.3 函数返回值的时候 - 如何优化呢
我们在main主函数上面加一个普通的全局函数：
CTempValue Double(CTempValue& ts)
{
CTempValue tmpm; //这里会消耗一次构造函数和一次析构函数的调用
tmpm.val1 = ts.val1 * 2;
tmpm.val2 = ts.val2 * 2;
return tmpm; //这里会调用构造函数和析构函数，这表示生成了一个临时对象
}
int main()
{
CTempValue ts1(10, 20);
CTempValue ts2 = Double(ts1); //其实临时对象接管的就是右值
CTempValue&& ts2 = Double(ts1);
}
临时对象就是一种右值
那如何优化呢？
CTempValue Double(CTempValue& ts)
{
return CTempValue(ts.val1 * 2, ts.val2 * 2);
}
通过如上的优化系统会调用一次拷贝构造函数，一次析构函数。
二、小结
（1）写代码的时候，减少临时变量的产生。
（2）锻炼眼神，能够尽量看出哪些地方可能会产生临时对象，尤其是一个函数只要返回一个对象，一般机会产生临时对象。
