第二十三课：神秘的临时对象----------狄泰软件学院

一、直接调用构造函数

#include<iostream>
using namespace std;
class Test
{
private:
    int mi;
public:
    Test(int v)
    {
        mi = v;
    }
    Test()
    {
        Test(0);//直接调用构造函数，看起来合情合理，但却是产生了一个临时对象，这句之后马上被析构，等价于这行根本没有
    }
    void print()
    {
        cout<<"mi = "<<mi<<endl;//最后打印mi的值为随机值  
    }
};
int main()
{
    Test t;
    t.print();
    cin.get();
    return 0;
}

本来的意图：
在Test()中以0作为参数调用Test（int i），想将成员变量mi的初始值设置为0
但最终mi的值却是随机值

原因：
1.直接调用构造函数将产生一个临时对象
2.临时对象的声明周期只有一条语句的时间
3.临时对象的作用域只在一条语句
4.临时对象是c++中值得警惕的灰色地带

解决方案：定义一个私有的初始化函数

#include<iostream>
using namespace std;
class Test
{
private:
    int mi;
    void init(int v)
    {
        mi = v;
    }
public:
    Test(int v)
    {
        mi = v;
    }
    Test()
    {
        init(2);
    }
    void print()
    {
        cout<<"mi = "<<mi<<endl;//最后打印mi的值为2
    }
};
int main()
{
    Test t;
    t.print();
    cin.get();
    return 0;
}

二、产生一个临时对象后马上调用print函数

#include<iostream>
using namespace std;
class Test
{
private:
    int mi;
    void init(int i)
    {
        mi = i;
    }
public:
    Test(int v)
    {
        cout<<"Test(int v) begin"<<endl;
        mi = v;
        cout<<"Test(int v) end"<<endl;
    }
    Test()
    {
        cout<<"Test() begin"<<endl;
        init(1);
        cout<<"Test() end"<<endl;
    }
    void print()
    {
        cout<<"mi = "<<mi<<endl;
    }
    ~Test()
    {
        cout<<"~Test()"<<endl;
    }

};
int main()
{
    cout<<"main() begin"<<endl;
    Test().print();
    Test(2).print();
    cout<<"main() endl"<<endl;  
    return 0;
}

打印结果：
main() begin
Test() begin
Test() end
mi = 1//先打印mi的值才调用析构函数
~Test()
Test(int v) begin
Test(int v) end
mi = 2
~Test()
main() endl
说明在那行程序完之后才调用析构函数

现代编译器在不影响最终执行结果的情况下极力减少临时对象的产生

#include<iostream>
using namespace std;
class Test
{
private:
    int mi;
public:
    Test(int v)
    {
        cout<<"Test(int v)"<<endl;
        mi = v;
    }
    Test(const Test& obj)
    {
        cout<<"Test(const Test& obj)"<<endl;
        mi = obj.mi;
    }
    void print()
    {
        cout<<"mi = "<<mi<<endl;
    }
    ~Test()
    {
        cout<<"~Test()"<<endl;
    }

};
int main()
{
    Test t = Test(10);;//1.生产一个临时对象 2.用临时对象初始化t  ===》调用拷贝构造函数（但是实际上并没有拷贝构造函数的迹象）
                      //少调用一次拷贝构造函数，最终等价于t=10;这里也就解决了之前Ta[3] = {Test(),Test(1),Test(2)}；合法的问题
    t.print();
        cout<<"main() end"<<endl;
    return 0;
}

打印结果：
Test(int v)
mi = 10
main() end
~Test()//析构函数被最后打印，且只调用了一次构造函数说明只是t在创建时调用了，而临时对象相当于没有

小结：

1.直接调用构造函数将产生一个临时对象
2.临时对象是性能的瓶颈，也是bug的重要来源之一
3.现代c++编译器会极力避免临时对象
4.程序设计中也要人为避开临时对象