变量生命周期

int main()
{
    Test t1(10);
    Test t2; // => 不要写成 test t2（） 会变成函数的声明
    Test t3(t2);
    Test t4 = t3;//t3拷贝构造t4

    // Test t5(40);
    Test t5 = Test(40); // 生成临时对象 Test(int)
/*
Test t5 = Test(40)
等于  Test t5(40)--
是用临时对象 拷贝构造同类型的对象 临时对象不产生 直接构造对象即可
不是 ：生成临时对象  拷贝构造t5  析构临时对象
*/
    cout << "-----------" << endl;


    t2 = t3;// 赋值
    t2 = Test(50); // 显式生成临时对象
//显式生成临时对象  这个临时对象是要产生的 然后给t2赋值 再析构临时对象
    t2 = 50; // 隐式生成临时对象 int -> Test(int)
//把其他类型转成类的类型 要看这个类有没有一个构造函数接收这个类型来生成临时对象

    cout << "-----------" << endl;
    return 0;
}

介绍变量生命周期，先看看下面程序中函数对象的调用情况
原本程序：

Test GetTestObject(Test t)
{
    int val = t.getData();
    Test tmp(val);
    return tmp;
}
int main()
{
    Test t1;
    Test t2;
    t2 = GetTestObject(t1);
    return 0;
}

函数调用情况：
构造t1
构造t2
t1拷贝构造临时形参对象t
构造tmp
tmp拷贝构造临时对象
析构tmp
析构形参对象t
临时对象赋值给t2
析构临时对象
析构t2
析构t1

优化1.函数调用传参数，如果是对象，形参按引用来接收
优化2.函数返回对象值的时候，应该返回临时对象
下面程序体现：

class Test
{
public:
    Test(int data=10):ma(data)
    {
        cout << "Test(int)" << endl;
    }
    ~Test()
    {
        cout << "~Test()" << endl;
    }
    Test(const Test &src) :ma(src.ma)
    {
        cout << "Test(const Test&)" << endl;
    }
    void operator=(const Test &src)
    {
        cout << "operator=" << endl;
        ma = src.ma;
    }
    int getData() { return ma; }
private:
    int ma;
};
Test GetTestObject(Test &t)
{
    int val = t.getData();
    return Test(val); // 生成临时对象
}
int main()
{
    Test t1;
    Test t2;
    t2 = GetTestObject(t1);
    return 0;
}

所以传值得时候传引用可以少两个函数：拷贝构造和析构
函数调用情况：
构造t1
构造t2
构造带整型参数的临时对象-----（因为用临时对象拷贝构造同类型的对象临时对象不产生直接构造对象即可）
临时对象赋值给t2
析构临时对象
析构t2
析构t1

注意：用临时对象拷贝构造同类型的对象的时候才优化

优化3.应该以初始化的方式接收返回值是临时对象的返回

Test GetTestObject(Test &t)
{
    int val = t.getData();
    return Test(val); // 生成临时对象
}
int main()
{
    Test t1;
    Test t2 = GetTestObject(t1);
    return 0;
}

函数调用情况：
构造t1
构造t2------刚刚是赋值所以要产生临时对象而现在是直接用临时对象构造同类型的对象所以直接构造临时对象完全不用产生
----所以应该以初始化的方式接收返回值是临时对象的返回
析构t2
析构t1

优化4.写右值引用
因为给tmp构造了10000*4的空间将数据拷贝进来给临时对象又析构掉tmp
费老大劲构造出来又析构掉
对于局部的临时的对象给外部对象拷贝构造或者重载会匹配带右值引用参数的拷贝构造和重载函数

class Test
{
public:
    Test()
    {
        mptr = new int[10000];
        cout << "Test()" << endl;
    }
    ~Test()
    {
        delete[]mptr;
        cout << "~Test()" << endl;
    }
    Test(const Test &src)
    {
        cout << "Test(const Test&)" << endl;
        /*mptr = new int[10000];
        for (int i = 0; i < 10000; ++i)
        {
            mptr[i] = src.mptr[i];
        }*/
    }
    //main栈临时对象  tmp
    Test(Test &&src) // 带右值引用参数的拷贝构造
    {
        cout << "Test(Test&&)" << endl;
        mptr = src.mptr;
        src.mptr = nullptr;
    }

    void operator=(const Test &src)
    {
        cout << "operator=" << endl;
        if (this == &src)
            return;


        delete[]mptr;


        mptr = new int[10000];
        for (int i = 0; i < 10000; ++i)
        {
            mptr[i] = src.mptr[i];
        }
    }
    void operator=(Test &&src) // 带右值引用参数的赋值函数
    {
        cout << "operator=(Test&&)" << endl;
        if (this == &src)
            return;

        delete[]mptr;

        mptr = src.mptr;
        src.mptr = nullptr;
    }
private:
    int *mptr;
};


Test GetTestObject(Test &t)
{
    Test tmp;
    return tmp;
}
int main()
{
    Test t1;
    Test t2;
    t2 = GetTestObject(t1);
    return 0;
}