23.临时对象

1 #include
2
3 class Test
4 {
5 int mi;
6 public:
7 Test(int i)
8 {
9 mi = i;
10 }
11 Test()
12 {
13 //程序的意图是把Test当成普通函数来使用以达到对mi赋值的目的但直接调用有参构造函数，会将产生临时对象。
14 //所以Test(0)相当于对新的临时对象的mi赋初值为0，而不是对这个对象本身mi赋值.
15 //临时对象没有名字
16
17 Test(0); //是临时对象，声明周期就这一行语句，过了一行就析构
18 //程序并没有将0设置到初始变量，而是产生临时对象
19 //等价于空的没有参数的构造函数 Test(){ }
20 }
21
22 void print()
23 {
24 printf("mi=%d\n",mi); //mi=456783
25 }
26
27 };
28
29
30 int main()
31 {
32 Test t;
33
34 t.print();
35
36 return 0;
37 }

1 #include
2
3 class Test
4 {
5 private:
6 int mi;
7
8 //正确的做法，是提供一个用来初始化的普通函数
9 void init(int i)
10 {
11 mi = i;
12 }
13
14 public:
15 //带参构造函数
16 Test(int i)
17 {
18 init(i);
19 }
20
21 //不带参构造函数
22 Test()
23 {
24 init(0);//调用普通的初始化函数，而不是带参的构造函数Test(int i);
25 }
26
27 void print()
28 {
29 printf("mi = %d\n", mi);
30 }
31 };
32
33
34 int main()
35 {
36 Test t;
37
38 t.print(); //mi并没被赋初始，这里会输出随机值
39
40 return 0;
41 }

1 #include
2
3 class Test
4 {
5 private:
6 int mi;
7
8 void init(int i)
9 {
10 mi = i;
11 }
12
13 public:
14 Test(int i)
15 {
16 printf("Test(int i)\n");
17 init(i);
18 }
19
20 Test()
21 {
22 printf("Test()\n");
23 init(0);
24 }
25
26 void print()
27 {
28 printf("mi = %d\n", mi);
29 }
30
31 ~Test()
32 {
33 printf("~Test()\n");
34 }
35 };
36
37
38 int main()
39 {
40 printf("main begin");
41
42 Test(); //直接调用构造函数，产生临时对象，声明周期和作用域都在本行
43 Test(10); //直接调用构造函数，产生临时对象，声明周期和作用域都在本行
44
45 /*打印结果
46 main begin
47 Test()
48 ~Test()
49 Test(int i)
50 ~Test()
51 main end
52 */
53
54 Test().print(); //生成临时对象，调用print()，合法；临时对象Test()也是合法的对象
55
56 Test(10).print();
57
58 /*打印结果
59 main begin
60 Test()
61 mi=0
62 ~Test()
63 Test(int i)
64 mi=10
65 ~Test()
66 main end
67 */
68
69
70
71 printf("main end");
72
73 return 0;
74 }

1 #include
2
3
4 //避开临时函数，直接调用构造函数就会产生一个临时对象
5 class Test
6 {
7 private:
8 int mi;
9 public:
10 Test(int i) //含参构造函数
11 {
12 printf("Test(int i) : %d\n", i);
13 mi = i;
14 }
15 Test(const Test& t) //拷贝构造函数
16 {
17 printf("Test(const Test& t) : %d\n", t.mi);
18 mi = t.mi;
19 }
20 Test() //无参构造函数
21 {
22 printf("Test()\n");
23 mi = 0;
24 }
25 void print()
26 {
27 printf("mi=%d\n", mi);
28 }
29 ~Test() //析构函数
30 {
31 printf("~Test()\n");
32 }
33 };
34
35 Test func()
36 {
37 return Test(20); //生成临时函数，
38 }
39
40 int main()
41 {
42 Test t = Test(10); //等价于Test t=Test(10) Test t(10);
43 //分析：将产生一个临时对象，并用这个对象去初始化t对象，会先调用Test(int i)，再调用Test(const Test& t)）初始化 t 对象
44 //用临时对象Test(10)初始化t对象，应该调用构造函数
45
46 //编译器 只是进行了参数构造函数调用 why?
47 //为杜绝临时对象产生，等价于====>>Test t=10;少调用一次构造函数，性能提升
48
49 Test t1 = func(); //初始化t1,只调用Test(int i) ，没有调用拷贝构造函数，减少临时对象产生
50 // 等价于Test t1=Test(20);====>>Test t1=20;编译器会自动降低临时对象
51
52 //说明：如果不优化，该行代码的行为：在func内部调用Test(20)，将产生一个临时对象,此时(Test(int i)被调用，然后按值返回，
53
54 //会调用拷贝构造函数Test(const Test&)产生第2个临时对象，最后用第2个临时对象去初始化tt对象，将再次调用Test(const Test& t)
55
56
57 Test t1 = 20;
58
59 t.print();
60 t1.print();
61
62 return 0;
63 }

//假设Test是一个类，构造函数为Test(int i);
Test func()
{
return Test(2); //若不优化，将产生临时对象，并返回给调用者
}

//Test a = func(); 这行代码，经过编译优化后的等价伪代码：
//从中可以发现，优化后，减少了临时变量的产生
Test a; //a只是一个占位符
func(a); //传入a的引用
void func(Test& t) //优化时，编译器在func函数中增加一个引用的参数
{
t.Test(2); //调用构造函数来构造t对象
}