32）（典型）构造和析构 拷贝构造 小样例

#include<iostream>
using namespace std;
class ABCD
{
public:
    ABCD(int a,int b,int c)
    {
        _a=a;
        _b=b;
        _c=c;
        cout<<"ABCD()的构造函数"<<"a:  "<<_a <<"b:  "<<_b <<"c:  "<<_c <<endl;    
    }
    ~ABCD()
    {
        cout<<"ABCD()的析构函数"<<endl;
    
    }
    int get_a()
    {
        return  _a;
    }


private:
    int _a;
    int _b;
    int _c;
};
class MyE
{
public:
    MyE():abcd1(1,2,3),abcd2(4,5,6),m(100)
    {
        cout<<"MyE()的构造函数"<<endl;
    }
    ~MyE()
    {
        cout<<"MYE()的析构函数"<<endl;
    }
    MyE(const MyE &another):abcd1(7,8,9),abcd2(10,11,12),m(100)
    
    {
        cout<<"MyE的拷贝构造函数"<<endl;
    }

public:
    ABCD abcd1;
    ABCD abcd2;
    int m;

};
/**
因为这个mye1是一个普通的变量，所以，
也就是实参给形参赋值，也就有了调用MyE的拷贝构造函数
*/
int doThing(MyE mye1)
{
    cout<<"dothing()函数"<<endl;
    cout<<mye1.abcd1.get_a()<<endl;
    return 0;
}
int run()
{
    MyE mye;
    doThing(mye);
    return 0;
}
int run2()
{
    cout<<"run2函数开始了"<<endl;
    ABCD(400,500,600);//临时对象的生命周期
    cout<<"run2结束了"<<endl;
    return 0;
}
int main()
{
    run();
    /**
    ①首先调用MyE的无参构造函数，就是MyE():abcd1(1,2,3),abcd2(4,5,6),m(100)
    ②然后运行那个doThing函数，将mye传进去了，（也就是实参给形参赋值嘛，所以，救调用MyE的拷贝构造函数。
    ③
    */
    return 0;
}

  结果截图：

然后，我调用那个 run2（）函数

#include<iostream>
using namespace std;
class ABCD
{
public:
    ABCD(int a,int b,int c)
    {
        _a=a;
        _b=b;
        _c=c;
        cout<<"ABCD()的构造函数"<<"a:  "<<_a <<"b:  "<<_b <<"c:  "<<_c <<endl;    
    }
    ~ABCD()
    {
        cout<<"ABCD()的析构函数"<<endl;
    
    }
    int get_a()
    {
        return  _a;
    }


private:
    int _a;
    int _b;
    int _c;
};
class MyE
{
public:
    MyE():abcd1(1,2,3),abcd2(4,5,6),m(100)
    {
        cout<<"MyE()的构造函数"<<endl;
    }
    ~MyE()
    {
        cout<<"MYE()的析构函数"<<endl;
    }
    MyE(const MyE &another):abcd1(7,8,9),abcd2(10,11,12),m(100)
    
    {
        cout<<"MyE的拷贝构造函数"<<endl;
    }

public:
    ABCD abcd1;
    ABCD abcd2;
    int m;

};
/**
因为这个mye1是一个普通的变量，所以，
也就是实参给形参赋值，也就有了调用MyE的拷贝构造函数
*/
int doThing(MyE mye1)
{
    cout<<"dothing()函数"<<endl;
    cout<<mye1.abcd1.get_a()<<endl;
    return 0;
}
int run()
{
    MyE mye;
    doThing(mye);
    return 0;
}
int run2()
{
    cout<<"run2函数开始了"<<endl;
    ABCD(400,500,600);//临时对象的生命周期，也就是创建完后吗，就被析构了
    cout<<"run2结束了"<<endl;
    return 0;
}
int main()
{
    //run();
    /**
    ①首先调用MyE的无参构造函数，就是MyE():abcd1(1,2,3),abcd2(4,5,6),m(100)
    ②然后运行那个doThing函数，将mye传进去了，（也就是实参给形参赋值嘛，所以，救调用MyE的拷贝构造函数。
    ③
    */
    run2();
    return 0;
}

  　　　　　　结果i就是：

3）然后还有一个代码：

#include<iostream>
using namespace std;
class MyTest
{
public:
    MyTest(int a,int b,int c)
    {
        _a=a;
        _b=b;
        _c=c;
    }
    MyTest(int a,int b)
    {
        _a=a;
        _b=b;
        MyTest(a,b,100);//产生了一个新的匿名对象(这里可以这么写，也就是产生一个对象，紧接着被析构了呗
    }
    ~MyTest()
    {
        cout<<"MyTest的析构函数开始啦    ----"<<_a<<" "<<_b<<" "<<_c<<endl;
    }
    int getC()
    {
        return _c;
    }
    void setC(int val)
    {
    _c=val;
    }
private:
    int _a;
    int _b;
    int _c;

};
int main()
{
    MyTest t1(1,2);
    //t1.setC(100);
    cout<<"MyTest的C数据   "<< t1.getC()<<endl;
    return 0;
}

结果是：　　　　

　　　　　　  在构造中调用构造是一个危险的行为