详解C++中对象的生存周期

临时对象，局部对象，静态局部对象，全局对象，静态全局对象的生成周期
class Test
{
public:
 Test(double c = double())
 {
 
  cout << "c:" << c << endl;
  ma = mb = 0;
  mc = c;
  cout << "Test(double):" << mc << endl;
 }
 Test(int a, float b, double c)
 {
  ma = a;
  mb = b;
  mc = c;
  cout << "Test(int,float,double):" << mc << endl;
 }
 Test(const Test& rhs)
 {
  ma = rhs.ma;
  mb = rhs.mb;
  mc = rhs.mc;
  cout << "Test(Test):" << mc << endl;
 }
 void Show()
 {
  cout << "mc:" << mc << endl;
 }
 Test& operator=(const Test& rhs)
 {
  if (this != &rhs)
  {
   ma = rhs.ma;
   mb = rhs.mb;
   mc = rhs.mc;
  }
  cout << "operator=(Test):" << mc << endl;
  return *this;
 }
 ~Test()
 {
  cout << "~Test():" << mc << endl;
 }
private:
 int ma;
 float mb;
 double mc;
};
Test gtest1(10, 20.1f, 1.1);
static Test gtest2(10, 20.1f, 1.2);
int main()
{
 Test ltest1(10, 20.2f, 2.1);  //调用构造函数生成局部对象，return后析构  2.1
 Test ltest2(2.2);            
 Test ltest3 = ltest1;//调用拷贝构造函数生成新对象      2.1
 ltest2 = ltest3;  //调用赋值运算符重载函数对已有对象进行赋值   2.1

 static Test ltest4(10, 20.3f, 2.4);//静态局部对象，此时调用构造函数，在main函数结束后析构

 Test ltest5 = Test(20, 20.1f, 2.5);  //当临时对象的作用是为了生成新对象时，只产生一个局部对象ltest5，用生成临时对象的方式（即调用构造函数）来生成新对象
 ltest5 = Test(30, 30.1f, 2.5);     //调用构造函数产生一个临时对象，再调用赋值运算符重载函数给ltest5赋值，这条语句结束后析构临时对象

 Test ltest6 = Test(20, 20.1f, 2.6);//临时对象的作用是为了生成新对象时，只产生一个对象ltest6，调用构造函数
 ltest6 = (Test)(30, 30.1f, 2.5);    //相当于强转，后面是逗号表达式，只看最后一个2.5，调用只有一个参数的构造函数产生一个临时对象

 Test* ptest7 = new Test(20, 20.4f, 2.7);//在堆区调用构造函数生成一个临时对象，指针指向这个临时对象，delete处析构这个对象，程序员手动调用和释放
 Test* ptest8 = &Test(20, 20.4f, 2.8);//产生一个临时对象，把对象地址传递给指针，这个语句结束就析构掉这个对象
 Test& ptest9 = Test(20, 20.4f, 2.9);//右边产生一个临时对象，引用不产生对象，但是引用提高了临时对象的优先级，相当于一个局部对象，在return后析构

 ptest8->Show();
 delete ptest7;

 Test test10[3];//产生三个局部对象
 
 ptest7 = NULL;
 ptest8 = NULL; //防止野指针造成危害
 cout << "--------------------" << endl;
 return 0;
}
Test gtest3(10, 20.1f, 1.3);//构造函数生成全局对象，最先产生
static Test gtest4(10, 20.1f, 1.4);
//先产生全局对象，按1，2，3，4的顺序产生全局对象，最后按4，3，2，1的顺序析构全局对象