c++类对象的生存周期

********************在这里我们会通过一个例子来给大家解释说明****************************

#include <iostream>
using namespace std;
class Test
{
public:
	Test(int a = 5,int b = 5):ma(a),mb(b)
	{
		cout<<"Test(int)"<<endl;
	}
	~Test()
	{
		cout<<"~Test()"<<endl;
	}

	Test(const Test &src):ma(src.ma),mb(src.mb)
	{
		cout<<"Test(const Test &)"<<endl;
	}

	void operator=(const Test &src)
	{
		ma = src.ma;
		mb = src.mb;
		cout<<"operator ="<<endl;
	}

private:
	int ma;
	int mb;
};

Test t1(10,10);//1
int main()
{
	Test t2(20,20);//2
	Test t3 = t2;//3
	static Test t4 = Test(30,30);//4
	t2 = Test(40,40);//5
	t2 = (Test)(40,40);//6
	t2 = 60;//7
	Test *p1 = new Test(70,70);//8
	Test *p2 = new Test[2];//9

        Test *p3 = &Test(80,80);//10
	Test &p4 = Test(90,90);//11

	delete p1;//12
	delete []p2;//13

	return 0;
}

Test t5(10,10);//14

/分析//

1:  因为对象t1处于全局中，所以t1最先被构造，调用构造函数

2：由于对象t5 也处于全局中，所以t5第二被构造，调用构造函数

3：在main函数中:t2在最前面，所以第三被构造，调用构造函数

4：对象t3调用拷贝构造函数（t3之前不存在），t2拷贝构造t3，所以第四被构造，调用拷贝构造函数

5：注释//4这一行是重点：原本先调用构造函数产生临时量（Test（30，30）），在调用=运算符重载将临时量赋给t4，在调用析构函数析构临时量；

但是，这一过程会被编译器给优化掉，不产生临时量，直接构造新对象。所以，那一行的代码的含义是：：：直接调用构造函数构造t4

6:注释//5这一行也是重点：由于t2之前已经存在，所以它的含义是：构造临时对象，在调用赋值函数，最后在调用析构函数析构临时量，注意不是析构t2对象。

7：注释//6：调用显式构造函数生成临时量，在调用赋值函数，最后再析构临时量

8：注释//7：调用隐式构造函数生成临时量，再调用赋值函数，最后在析构临时量

9：注释//8：调用构造函数产生对象，因为有new没有delete所以当前不析构

10：注释//9：调用两次构造函数产生两个对象，因为有new没有delete所以当前不析构

11：注释//10：调用构造函数产生临时对象，在调用赋值函数，最后再析构p3

12:注释//11：调用构造函数构造p4

13：注释//12：析构p1所指堆上的对象

14：注释//13：调用两次析构函数析构p2所指堆上的两个对象

15：最后析构：p4，t4，t3，t2，t5，t1。

接下来我们看一下打印的结果：

**************************大家可以根据结果再仔细分析推敲**********************************