成员对象和封闭类

成员对象和封闭类

有成员对象的类叫封闭类

class CTyre  //轮胎类
{
private:
    int radius;   //半径
    int width;    //宽度
public:
    CTyre(int r, int w):radius(r), width(w) {}
};

class CEngine   //引擎类
{
};

class 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, w) {}

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

    return 0;
}
/*
上例中，如果CCar类不定义构造函数，则“CCar car;”这条语句编译会出错。（原因：编译器不知道car.tyre该如何初始化。car.engine可用默认构造函数初始化）
任何生成封闭类对象的语句，都要让编译器明白，对象中的成员对象是如何初始化的。（具体做法：通过封闭类的构造函数的初始化列表）
成员对象初始化列表中的参数可以是任意复杂的表达式（包括函数、变量，只要表达式中的函数或者变量有定义就行）
*/

封闭类构造函数和析构函数的执行顺序

1、封闭类对象生成时，先执行所有对象成员的构造函数，然后才执行封闭类的构造函数。
2、对象成员的构造函数调用次序和对象成员在类中的说明次序一致，与它们在成员初始化列表中出现的次序无关。
3、当封闭类的对象消亡时，先执行封闭类的析构函数，然后再执行成员对象的析构函数。次序和构造函数的调用次序相反。

//封闭类实例：
class CTyre
{
public:
    CTyre()
    {
        cout << "CTyre contructor" << endl;
    }
    ~CTyre()
    {
        cout << "CTyre destructor" << endl;
    }
};

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

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

int main()
{
    CCar car;

    return 0;
}
/*
输出：
CEngine contructor
CTyre contructor
CCar contructor
CCar destructor
CTyre destructor
CEngine destructor
*/

封闭类的复制构造函数

class A
{
public:
    A()
    {
        cout << "default" << endl;
    }
    A(A &a)
    {
        cout << "copy" << endl;
    }
};

class B
{
    A a;
};

int main()
{
    B b1, b2(b1);  //b2.a是用类A的复制构造函数初始化的。而且调用复制构造函数的实参就是b1.a

    return 0;
}
/*
default
copy
*/