成员对象和封闭类

成员对象和封闭类：
    一个类的成员变量如果是另一个类，就称之为成员对象。包含成员对象的类叫做封闭类。
 当封闭类的对象产生并初始化时，它包含的成员对象也需要被初始化，这时就会引发对成员对象
 构造函数的调用。如何让编译器知道到底是使用哪个构造函数初始化的呢？这可以通过在定义封
 闭类的构造函数时，添加初始化列表的方式解决。
 在构造函数中添加初始化列表的写法如下：
     类名::构造函数名(参数名):成员变量1(参数表),成员变量2(参数表),......
  {
      ......
     }
     初始化列表中的成员变量既可以是成员对象，也可以是基本类型的成员变量。对于成员对象，
  参数列表中的参数就是其构造函数的参数，对于基本类型成员变量，参数表中就是一个初始
  值。

using namespace std;

class CTyre{
    private:
        int radius;
        int width;
    public:
        CTyre(int r, int w):radius(r), width(w){
            
        }
};

class CEngine{
    
};

class CCar{               // CCar是一个封闭类 
    private:
        int price;
        CTyre tyre;
        CEngine engine;
    public:
        CCar(int p, int tr, int tw);
};

CCar::CCar(int p, int tr, int tw):price(p), tyre(tr, tw){
    
}

int main()
{
    CCar car(20000, 17, 225);
    
    return 0;
}

 封闭类对象生成时，先执行所有成员对象的构造函数，然后才执行封闭类自己的构造函数。
    当封闭类对象消亡时，先执行封闭类的析构函数，然后再执行成员对象的析构函数。

    封闭类的对象，如果是使用默认复制构造函数初始化的那么它包含的成员对象也会用复制构造函数初始化

#include <iostream>

using namespace std;

class CTyre{
    public:
        CTyre(){
            cout << "CTyre constructor" << endl;
        }
        ~CTyre(){
            cout << "CTyre destructor" << endl;
        }
};

class CEngine{
    public:
        CEngine(){
            cout << "CEngine constructor" << endl;
        }
        ~CEngine(){
            cout << "CEngine destructor" << endl;
        }
};

class CCar{
    private:
        CEngine engine;
        CTyre tyre;
    public:
        CCar(){
            cout << "CCar constructor" << endl;
        }
        ~CCar(){
            cout << "CCar destructor" << endl;
        }
};

int main()
{
    CCar car;
    
    return 0;
}

/*
输出结果：
    CEngine constructor
    CTyre constructor
    CCar constructor
    CCar destructor
    CTyre destructor
    CEngine destructor 
*/