神秘的临时对象

1 有趣的问题

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

实例分析：有趣的问题

#include <stdio.h>

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


int main()
{
    Test t;

    t.print();

    return 0;
}

发生了什么

• 程序意图：

  • 在Test()中以0作为参数调用Test(int i);
  • 将成员变量mi的初始值设置为0。

• 运行结果：

  • 成员变量mi的值为随机值。

究竟哪个地方出了问题？

思考

• 构造函数是一个特殊的函数：
  
  • 是否可以直接调用？（可以，手工调用构造函数）
  • 是否可以在构造函数中调用构造函数？（可以，编译不会报错）
  • 直接调用构造函数的行为是什么？

2 临时对象

• 直接调用构造函数的地方将产生一个临时对象。
• 临时对象的生命周期只有一条语句的时间。
• 临时对象的作用域只在一条语句中。
• 临时对象是C++中值得警惕的灰色地带。

编程实验：解决方案

#include <stdio.h>

class Test {
    int mi;

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


int main()
{
    Test t;

    t.print();

    return 0;
}

编译器的行为

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

编程实验：神秘的临时对象

#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;
    }
    int 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.用临时对象初始化t对象。
                       //==> 调用拷贝构造函数（为了高效，编译器进行了优化，忽略了这个过程）
    Test tt = func();  // ==> Test tt = Test(20); ==> Test tt = 20;

    t.print();
    tt.print();

    return 0;
}

小结

• 直接调用构造函数将产生一个临时对象。
• 临时对象是性能的瓶颈，也是bug的来源之一。
• 现代C++编译器会尽力避开临时对象。
• 实际工程开发中需要人为避开临时对象。