1. 有趣的问题
（1）程序意图：在Test()中以0作为参数调用Test(int i)来将成员变量mi初始值设置为0.
（2）运行结果：成员变量mi的值为随机值（没达到目的！）
【实例分析】有趣的问题 23-1.cpp
#include <stdio.h> class Test { private: int mi; public: //带参构造函数 Test(int i) { mi = i; } //不带参构造函数 Test() { //程序的意图是把Test当成普通函数来使用以达到对mi赋值的目的但直接调用构造函数，会将产生临时对象。 //所以Test(0)相当于对新的临时对象的mi赋初值为0，而不是对这个对象本身mi赋值. Test(0); } void print() { printf("mi = %d ", mi); } }; int main() { Test t; t.print(); //mi并没被赋初始，这里会输出随机值. return 0; }
运行结果：
2. 临时对象
（1）构造函数是一个特殊的函数，调用构造函数将产生一个临时对象
（2）临时对象的生命期只有一条语句的时间
（3）临时对象的作用域只在一条语句中
（4）临时对象是C++中值得警惕的灰色地带
【编程实验】解决方案 23-2.cpp
#include <stdio.h> class Test { private: int mi; //正确的做法，是提供一个用来初始化的普通函数 void init(int i){ mi = i;} public: //带参构造函数 Test(int i) { init(i); } //不带参构造函数 Test() { init(0);//调用普通的初始化函数，而不是带参的构造函数Test(int i); } void print() { printf("mi = %d ", mi); } }; int main() { Test t; t.print(); //mi并没被赋初始，这里会输出随机值 return 0; }
运行结果：
3. 临时对象与返回值优化（RVO）
（1）现代C++编译器在不影响最终执行结果的前提下，会尽力减少临时对象的产生。
【编程实验】神秘的临时对象 23-3.cpp
#include <stdio.h> class Test { private: int mi; public: //带参构造函数 Test(int i) { mi = i; printf("Test(int i): %d ", i); } //不带参构造函数 Test() { mi = 0; printf("Test() "); } //拷贝构造函数 Test(const Test& t) { mi = t.mi; printf("Test(cosnt Test& t): %d ", t.mi); } void print() { printf("mi = %d ", mi); } ~Test(){printf("~Test() ");} }; Test func() { return Test(20); } int main() { Test t = Test(10); //==> Test t = 10，临时对象被编译器给“优化”掉了说明：如果不优化，该行代码的行为：调用Test(10) //将产生一个临时对象，并用这个对象去初始化t对象，会先调用Test(int i)，再调用Test(const Test& t) Test tt = func(); //==> Test tt = Test(20);==>Test tt = 20; //说明：如果不优化，该行代码的行为：在func内部调用Test(20)，将产生一个临时对象,此时(Test(int i)被调用，然后按值返回， //会调用拷贝构造函数Test(const Test&)产生第2个临时对象，最后用第2个临时对象去初始化tt对象，将再次调用Test(const Test& t) t.print(); tt.print(); return 0; }
//实际输出（优化后）结果（在g++下，可以关闭RVO优化再测试：g++ -fno-elide-constructors test.cpp）
//Test(int i): 10
//Test(int i): 20
//~Test()
//~Test()
（2）返回值优化（RVO）
//假设Test是一个类，构造函数为Test(int i); Test func() { return Test(2); //若不优化，将产生临时对象，并返回给调用者 }
返回值优化（RVO）：
①在没有任何“优化”之前，return Test(2)代码的行为这行代码中:
先构造了一个 Test 类的临时的无名对象（姑且叫它t1），接着把 t1 拷贝到另一块临时对象 t2（不在栈上），然后函数保存好 t2 的地址（放在 eax 寄存器中）后返回，Func的栈区间被“撤消”（这时 t1 也就“没有”了，t1 的生存期在Func中，所以被析构了），在 Test a = TestFun(); 这一句中，a利用t2的地址，可以找到t2，接着进行构造。这样a的构造过程就完成了。然后再把 t2 也“干掉”。
②经过“优化”的结果
可以看到，在这个过程中，t1和t2 这两个临时的对象的存在实在是很浪费的，占用空间不说，关键是他们都只是为a的构造而存在，a构造完了之后生命也就终结了。既然这两个临时的对象对于程序员来说根本就“看不到、摸不着”（匿名对象），于是编译器干脆在里面做点手脚，不生成它们！怎么做呢？很简单，编译器“偷偷地”在我们写的TestFun函数中增加一个参数 Test&，然后把a的地址传进去（注意，这个时候a的内存空间已经存在了，但对象还没有被“构造”，也就是构造函数还没有被调用），然后在函数体内部，直接用a来代替原来的“匿名对象”，在函数体内部就完成a的构造。这样，就省下了两个临时变量的开销。这就是所谓的“返回值优化”！
③编译器“优化”后的伪代码
//Test a = func(); 这行代码，经过编译优化后的等价伪代码： //从中可以发现，优化后，减少了临时变量的产生 Test a; //a只是一个占位符 func(a); //传入a的引用 void func(Test& t) //优化时，编译器在func函数中增加一个引用的参数 { t.Test(2); //调用构造函数来构造t对象 }
4. 小结
（1）直接调用构造函数将产生一个临时对象
（2）临时对象是性能的瓶颈，也是bug的来源之一
（3）现代C++编译器会尽力避开临时对象
（4）实际工程开发中需要人为的避开临时对象