代码1

#include <iostream>
using namepspace std;

class Test
{
	public:
	    Test(int a=10):ma(a){cout<<"Test()"<<endl;}
	    ~Test(){cout<<"~Test()"<<endl;}
            Test(const Test & t):ma(t.ma){cout<<"Test(const Test & t)"<<endl;}
	    Test & operator =(const Test & t){
		 if(this==&t){return *this;}
	         ma=t.ma;
	         return *this;
	    }

	private:
	    int ma;
};

int main(){

   Test t1();  //构造函数
   Test t2(t1);//拷贝构造
   Test t3=t1; //拷贝构造
   Test(20);   //显示生成一个临时对象,生存周期，所在语句
  
   Test t4=Test(20);//这里并不会先Test(20)创建临时对象,再用临时对象拷贝构造Test
   //上面会优化直接使用构造函数 和 Test t4(20)没有区别
   //C++编译器对于对象构造的优化,用临时对象生成新对象的时候,这个临时对象不会产生
   //直接构造新对象就可以了


   //赋值函数
   t4=t2;

   //t4是已经存在的对象
   //会生成一个临时对象,用这个临时对象给t4赋值,这句话还要做临时对象析构
   t4=Test(30);

   //int->Test 的时候,Test有没有合适的带整形参数的构造函数,显示的调用Test构造函数 创建临时对象
   t4=(Test)30;
   
   //int->Test 的时候,Test有没有合适的带整形参数的构造函数 隐式转换 创建临时对象
   t4=30;
   
   
   //创建一个临时对象,用p指针指向这个临时对象,但是出了这个语句，这个临时对象就析构了,
   //这个指针指向了一个析构的对象了!!不可以.
   Test *p =&Test(40);
  
   //Test(50);会创建一个临时对象,但是指定了一个引用(别名)指向他后,这个临时对象不会产生
   //出了这个语句不会析构,这个是可以
   const Test &ref=Test(50);

   return 0;
}

代码2

#include <iostream>
using namespace std;

class Test
{
	public:
	    Test(int a=10,int b=20):ma(a),mb(b){cout<<"Test(int,int)"<<endl;}
	    ~Test(){cout<<"~Test()"<<endl;}
	    Test(const Test & t):ma(t.ma),mb(t.mb){cout<<"Test(const Test & t)"<<endl;}
	    Test & operator =(const Test & t){
		     if(this==&t){return *this;}
		     ma=t.ma;
		     mb=t.mb;
		     cout<<"operator="<<endl;
		     return *this;
	    }

	private:
	    int ma;
            int mb;
};

//程序启动后,全局变量先构造, 第1个创建
//第12个析构
Test t1(10,20);

int main(){
	
	//Test(int,int) 第3个构造
	//第9个析构
        Test t2(30,40);
	
	//拷贝构造t3，第4个构造
	//第8个析构
        Test t3=t2;
	
	//静态局部变量,在程序运行的时候,内存已经分配好,但是没有初始化
	//初始化要等到第一次运行的时候才初始化
	//构造函数 第5个构造 创建t4,不产生临时对象，等价static Test t4(40,50)
	//第10个析构
        static Test t4=Test(40,50);
	
	//构造函数 第6个构造，创建临时对象给t2赋值,出语句析构临时对象
        // 第1个析构
	t2=Test(1,2);
	
	//构造函数 第7个构造，创建临时对象给t2赋值,出语句析构临时对象
        //Test(50,500) 调用的是 Test(int a=50,int b=500)的构造函数,(Test)(50,500) （50,500）是表达式结果是500,
        //然后调Test(int a=500,int b=20默认值) 进行对象构造
	//第二个析构
        t2=(Test)(50,500);
	
	//隐式构造,构造函数Test(60,20) 第8个构造，创建临时对象给t2赋值,出语句析构临时对象
	//第三个析构
        t2=60;
	
	//堆上构造对象,构造函数Test(60,20) 第9个构造，指针指向堆地址
	//第5个析构
        Test *p1=new Test(8,9);
	
	//堆上构造2个对象,2次调用构造函数Test(10,20) 第10个构造，指针指向首元素地址
	//第6个析构
        Test *p2=new Test[2];
	
	//第11个构造 栈上创建临时对象,Test(80,80)，指针指向临时对象,出作用域后,析构该临时对象
	//第4个析构
        Test *p3=&Test(80,80);
	
	//第12个构造 栈上创建临时对象,Test(90,100) 引用指向该临时对象,引用指向临时对象后，该对象
	//不再是临时对象,出了这个语句不析构
	//第7个析构
        const Test &p4=Test(90,100);
	
        //调用P1指向析构函数
	delete p1;
        //调用析构函数,析构2个对象
	delete[] p2;
	
        return 0;
}

//第2个创建 构造函数
//第11个析构
Test t5(200, 250);