23-神秘的临时对象

注：博客中内容主要来自《狄泰软件学院》，博客仅当私人笔记使用。

测试环境：Ubuntu 10.10

GCC版本：4.4.5

 

一、有趣的问题

1）下面的程序输出什么？为什么？

 

实例分析
23-1.cpp
#include <stdio.h>

class Test {
    int mi;
public:
    Test(int i) {
        mi = i;
    }
    Test() {
        Test(0);    //这里产生临时对象，等价于注释掉这行语句，因此mi没有赋值
    }
    void print() {
        printf("mi = %d\n", mi);
    }
};


int main()
{
    Test t;
    
    t.print();

    return 0;
}

操作：

1) g++ 23-1.cpp -o 23-1.out编译正常，打印结果：

mi = -1216950272

分析：

        Test(0);没有起到任何作用，mi没有被初始化为0。为什么会这样？

 

二、发生了什么

1）程序意图：

    -    在Test()中以0作为参数调用Test(int i)

    -    将成员变量mi的初始值设置为0

2）运行结果：

    -    成员变量mi的值为随机值

            究竟哪个地方出了问题？

 

三、思考

1）构造函数是一个特殊的函数

        -    是否可以直接调用？

        -    是否可以在构造函数中调用构造函数？

        -    直接调用构造函数的行为是什么？

 

四、答案

1）直接调用构造函数将产生一个临时对象（临时对象产生的一种方式）

2）临时对象的生命周期只有一条语句的时间

3）临时对象的作用域只在一条语句中

4）临时对象是C++中值得警惕的灰色地带

编程实验
解决方案——去掉了构造函数，用成员函数解决
23-2.cpp
#include <stdio.h>

class Test {
    int mi;
    
    void init(int i)
    {
        mi = i;
    }
public:
    Test(int i) {
        printf("Test(int i)\n");
        init(i);
    }
    Test() {
        printf("Test()\n");
        init(0);
    }
    void print() {
        printf("mi = %d\n", mi);
    }
    ~Test()
    {
        printf("~Test()\n");
    }
};

int main()
{
    Test t;
    
    t.print();
    printf("main begin\n");
    Test().print();
    Test(10).print();    //应该打印10，但结果不是10
    printf("main end\n");
    return 0;
}

操作：

1) g++ 23-2.cpp -o 23-2.out编译正常，打印结果：

Test()
mi = 0    
main begin    
Test()    
mi = 0    
~Test()
Test(int i)    
mi = 0    //应该打印10，打印0很奇怪
~Test()    
main end    
~Test()    

分析：

        Test(10).print();应该打印10，但打印0。

 

五、编译器的行为

        现代C++编译器在不影响最终执行结果的前提下，会尽力减少临时对象的产生！！！

 

编程实验
神秘的临时对象
23-3.cpp
#include <stdio.h>

class Test
{
    int mi;
public:
    Test(int i)
    {
        printf("Test(int i) : %d\n", i);
        mi = i;
    }
    
    Test(const Test& t)    //拷贝构造函数
    {
        printf("Test(const Test& t) : %d\n", t.mi);
        mi = t.mi;
    }
    
    Test()
    {
        printf("Test()\n");
        mi = 0;
    }
    
    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（建议用这种赋值）（编译器杜绝了临时对象产生，提高代码运行速度）;
    //1.生成临时对象 2.用临时对象初始化tt对象==>调用拷贝构造函数
    Test tt = func();  // ==> Test tt = Test(20); ==> Test tt = 20（建议用这种赋值）; 
    
    t.print();    //mi = 10
    tt.print();   //mi = 20
    
    return 0;
}

操作：

1) g++ 23-3.cpp -o 23-3.out编译正常，打印结果：

Test(int i): 10
Test(int i): 20
mi = 10    
mi = 20    
~Test()    
~Test()    

分析：

        Test t = Test(10);从结果等价Test t = 10。因为编译器杜绝了临时对象产生，提高代码运行速度。这种代码书写方式依赖编译器优化，并不是好的编码方式。

        Test tt = func();==> Test tt = Test(20); ==> Test tt = 20;这里也被编译器优化了临时对象。

 

小结

1）直接调用构造函数将产生一个临时对象（产生临时对象的方式，应杜绝）

2）临时对象是性能的瓶颈，也是bug的来源之一

3）现代C++编译器会尽力避开临时对象

4）实际工程开发中需要人为的避开临时对象