类对象的生存周期

让我们来从代码中看下对象的生存周期：

class Test
{
public:
Test(int a=10, int b=10)
{
ma = a;
mb = b;
cout<<"ma:"<<ma<<" mb:"<<mb<<endl;
cout<<"Test(int) "<<this<<endl;

}
Test(const Test &src)
{
ma = src.ma;
mb = src.mb;
cout<<"ma:"<<ma<<" mb:"<<mb<<endl;
cout<<"Test(const Test&) "<<&src<<"->"<<this<<endl;
}

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

~Test()
{
cout<<"ma:"<<ma<<" mb:"<<mb<<endl;
cout<<"~Test() "<<this<<endl;
}
void Show(){cout<<"ma:"<<ma<<" mb:"<<mb<<endl;}
int GetValue1(){return ma;}
int GetValue2(){return mb;}
private:
int ma;
int mb;
};

//返回一个对象，会产生临时对象，因为带回一个对象，要先构造
Test GetObject(Test t)
{
int a = t.GetValue1();
int b = t.GetValue2();
Test tmp(a,b);
//tmp拷贝构造临时对象，函数调用之前产生临时对象  临时量的地址    ebp+8（最后入栈的）
return tmp;
}
int main()
{
Test t1(10, 10);
Test t2;
//   内存(放临时对象)  传入临时量地址  GetObject(void*, t1)
t2=GetObject(t1);  // func()  ->   func(void*)
cout<<"-----------------"<<endl;
t2.Show();
return 0;
}

main()函数中类对象的生存周期：先构造t1,再构造t2, t1拷贝构造给t ,构造tmp,tmp拷贝构造临时变量，析构tmp,析构t,临时变量赋值给t2,析构临时变量，析构t2 t1

但上述代码仍需继续优化，将其GetObject（）函数稍作改变：

//这里用引用优化了参数的生成，没有实参拷贝构造形参，也少了形参的析构
Test GetObject(Test &t)
{
int a = t.GetValue1();
int b = t.GetValue2();
//返回正在生成的对象/临时对象  因为这里是用临时对象生成一个新对象，所以不产生临时变量（直接构造临时对象）
return Test(a, b);
}

int main()
{
Test t1(10, 10);
Test t2;
//   内存(放临时对象)    GetObject(void*, t1)
t2=GetObject(t1);
t2.Show();
return 0;
}

这里的main()函数先构造t1 t2,子函数产生返回临时变量，临时变量赋值给t2,析构临时变量，析构t2 析构t1，是不是和上一步相比少了些许构造和析构呢？答案是肯定的。

然后我们还可以进一步优化：

Test GetObject(Test &t)
{
int a = t.GetValue1();
int b = t.GetValue2();
return Test(a, b);//返回正在生成的对象

int main()
{
Test t1(10, 10);

//   内存(放临时对象)    GetObject(void*, t1)
Test t2=GetObject(t1);//直接定义并初始化

t2.Show();

return 0;
}

当我们在主函数中直接定义并初始化的时候，与上一步相比，少了一次构造和赋值，也少了一次析构。因为这里是临时对象构造一个新的对象，临时对象被优化。相当于在返回的时候直接就构造了t2。

让我们接下来看另一个例子：

class Cgoods
{
public:
//直接构造--初始化
Cgoods(char *n,int m,float p);
//拷贝构造函数 ，按引用接收，如果是值将进入死循环
Cgoods(const  Cgoods &src);
//赋值运算符重载--赋值运算符可以是引用或传递值，若是引用会减少形参对象的生成
void operator=(const  Cgoods &src);
//析构函数--释放占用的外部资源
~Cgoods();

private:
char* mName;
int mAmount;
float price;
};

Cgoods ::Cgoods(char *n,int m,float p)
{
cout<< this<<endl;
cout<< "Cgoods(char *n,int m,float p)"<<endl;
mName=new [strlen(n)+1];
strcpy(mName,n);
mAmount=m;
price=p;

}

Cgoods ::Cgoods(const  Cgoods &src)
{
cout<<&src<<"->"<< this<<endl;
cout<<"Cgoods(const  Cgoods &src)"<<endl;
mName=new [strlen(src.mName)+1];
strcpy(mName,src.mName);
mAmount=src.mAmount;
price=src.price;
}

void Cgoods ::operator=(const  Cgoods &src)
{
cout<<&src<<"->"<< this<<endl;
cout<<"operator=(const  Cgoods &src)"<<endl;

if (&src==this)//防止自赋值
{
return ;
}

delete []mName;//释放原来的资源
mName=NULL;

mName=new [strlen(src.mName)+1];
strcpy(mName,src.mName);
mAmount=src.mAmount;
price=src.price;
}

Cgoods::~Cgoods()
{
delete []mName;
mName=NULL;
}
void fun(Cgoods *pgood)
{
cout<<"call func"<<endl;
}
int main()
{
//先构造--显式生成临时变量---传参--打印call func---调用析构函数
//主要是看临时对象的生存周期（在这个函数调用完成之后临时对象将不存在）
func(Cgoods ("shangpin1",14,14.1));

//先构造的后析构
//构造函数在对象定义时产生汇编
Cgoods good1("shangpin1",14,14.1);
Cgoods good2(good1);//拷贝构造

//先构造带三个参数的构造函数然后直接构造good3

Cgoods("shangpin1",15,15.1)//显示生成临时对象
//当一个临时对象构造一个新对象的时候，临时对象会被优化
Cgoods good3=Cgoods("shangpin1",15,15.1);

//先构造带三个参数的构造函数，显式生成临时对象，将临时对象赋值构造给good3，析构临时变量
//下面这两种都是显式生成临时对象，当只有一个参数时，这两种函数等价，有多个参数时，不等价
good3=Cgoods("shangpin1",16,16.1);
good3=(Cgoods)("shangpin1",16,16.1);//类型转化  逗号表达式  将double类型转化为Cgoods,寻找带有该类型的构造函数

//隐式生成临时对象，将临时对象赋值给good3,析构隐式生成临时对象
good3=40.1;

//不管是显式生成临时对象还是隐式生成临时对象，初始化不产生临时对象，赋值才会产生临时对象
Cgoods good4=60.8;

//临时对象的生存周期是其所在的语句，或是所在函数的调用结束（不包括引用变量引用的临时对象）
//这里的good5之所以析构是临时对象的生存周期结束
//指针有自己独立的内存，而引用没有自己对立的内存。引用就像一块橡皮糖，引用变量所引用的临时量的生存周期是引用变量的生存周期，也就是这个临时对象的生存周期
Cgoods *good5=&Cgoods("shangpin1",17,17.1);//先构造--产生临时对象--析构临时对象
Cgoods &good6=Cgoods("shangpin1",18,18.1);//先构造--产生临时对象---这里先不析构

return 0;//析构函数产生
}