1. 有趣的问题
（1）程序意图：在Test()中以0作为参数调用Test(int i)来将成员变量mi初始值设置为0.
（2）运行结果：成员变量mi的值为随机值（没达到目的！）
【实例分析】有趣的问题
#include <stdio.h>
class Test
{
private:
int mi;
public:
//带参构造函数
Test(int i)
{
mi = i;
}
//不带参构造函数
Test()
{
Test(0);//程序的意图是把Test当成普通函数来使用以达到对mi赋值的目的但直接调用构造函数，会将产生临时对象。所以Test(0)相当于
//对新的临时对象的mi赋初值为0，而不是对这个对象本身mi赋值
}
void print()
{
printf("mi = %d\n", mi);
}
};
int main()
{
Test t;
t.print(); //mi并没被赋初始，这里会输出随机值
return 0;
}
2. 临时对象
（1）构造函数是一个特殊的函数，调用构造函数将产生一个临时对象
（2）临时对象的生命期只有一条语句的时间
（3）临时对象的作用域只在一条语句中
（4）临时对象是C++中值得警惕的灰色地带
【编程实验】解决方案
#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\n", mi);
}
};
int main()
{
Test t;
t.print(); //mi并没被赋初始，这里会输出随机值
return 0;
}
3. 临时对象与返回值优化（RVO）
（1）现代C++编译器在不影响最终执行结果的前提下，会尽力减少临时对象的产生。
【编程实验】神秘的临时对象
#include <stdio.h>
class Test
{
private:
int mi;
public:
//带参构造函数
Test(int i)
{
mi = i;
printf("Test(int i): %d\n", i);
}
//不带参构造函数
Test()
{
mi = 0;
printf("Test()\n");
}
//拷贝构造函数
Test(const Test& t)
{
mi = t.mi;
printf("Test(cosnt Test& t): %d\n", t.mi);
}
void print()
{
printf("mi = %d\n", mi);
}
~Test(){printf("~Test()\n");}
};
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;
}
//实际输出（优化后）结果
//Test(int i): 10
//Test(int i): 20
//~Test()
//~Test()
（2）返回值优化（RVO）
//假设Test是一个类，构造函数为Test(int i);
Test func()
{
return Test(2);//若不优化，将产生临时对象，并返回给调用者
}
①在没有任何“优化”之前，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）实际工程开发中需要人为的避开临时对象