匿名对象的生命周期

1、匿名对象想的生命周期

class  ABCD
{
   public:
         ABCD(int _a,in t_b)
       {
            a=_a;
             b=_b
           cout<<"ABCD的构造函数"<<endl;
      }
    ~ ABCD()
       {
           cout<<"ABCD的析构函数"<<endl;
      }
private：
   int a;
   int b;
}
int run1()
{
  ABCD(100);//执行完构造函数后立即执行析构函数，因为匿名对象没有任何变量承接
  count <<"run1 end\n"<<endl;

}
int run2()
{
  ABCD abcd=ABCD(100);
  count <<"run2 end\n"<<endl;


}
void main()
{
   run1();//输出顺序：ABCD的构造函数   ABCD的析构函数   run1 end
   run2();//输出顺序：ABCD的构造函数   run2 end      ABCD的析构函数   
}

2、构造函数中调用构造

class  ABCD
{
   public:
         ABCD(int a,in b,int c)
       {
            this->a=a;
            this->b=b;
           his->c=c;
           cout<<"ABCD的构造函数"<<endl;
      }
    ABCD(int a,in b)
    {
       this->a=a;
       this->b=b;
        ABCD(a, b,100);//产生匿名对象，如果没有对象去接。就会调用析构函数
    }
    ~ ABCD()
       {
           cout<<"ABCD的析构函数"<<endl;
      }
private：
   int a;
   int b;
   int c;
public():
        int getC() const{return C;}
        void getC(int val){c=val;}
};

int main()
{
    ABCD  t1(1,2);//调用有两个参数的析构函数，执行ABCD(a, b,100);产生匿名对象，和t1没有关系，如果没有对象去接，就会调用析构函数，所以c会是个乱码
    printf("%d",t1.getC());//输出c为乱码
    sysytem("pause");
    return 0;
}

如题所示：执行的情况：定义一个对象，有三个变量，执行析构函数，给a,b赋值，执行ABCD(a, b,100)，产生一个匿名对象，执行完这一句就会执行匿名对象的析构函数，然后匿名对象被析构掉，全程并没有对c赋值，所以c为乱码