C++学习笔记8：成员对象与封闭类

1 定义：有成员对象的类叫封闭类。
2 例子：（见本工程closeclass.cpp）

//
// 封闭类例子
//

#include <iostream>

using namespace std;

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; // tyre 和 engine是成员对象，CCar包含成员对象，因此CCar是封闭类
    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;
}

在该例子中，如果CCar类不定义构造函数，则下面的语句会编译出错：CCar car;
因为编译器不明白car.typleie该如何初始化，car.engine的初始化没问题，用默认构造函数就可以。

3 任何生成封闭类对象的语句，都要让编译器明白，对象中的成员对象，是如何初始化的。
具体做法：通过封闭类的构造函数的初始化列表。

4 成员对象初始化列表中的参数可以是任意复杂的表达式，可以包括函数，变量，只要表达式中的函数或变量有定义就可以。

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

6 封闭类调用例子（见本工程closeclass2.cpp）

//
// 演示封闭类成员函数和析构函数调用次序
//

#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;
}

7 封闭类的复制构造函数（见本工程closeclasscopy.cpp）

/**
 * 封闭类的复制构造函数演示
 *
 * 输出结果：
 * default
 * copy
 *
 * 解释：说明b2.a是用类A的复制构造函数初始化的。而且调用复制构造函数时的实参就是b1.a
 * 无参构造函数初始化b1的时候，b1.a如何初始化？ 由于没有交代，所有使用class A的无参构造函数初始化，所以输出default
 * 生成b2的时候使用class B的默认复制构造函数进行初始化b2,那么b2.a如何初始化呢？  用class A的复制构造函数去初始化b2.a, 吧b1.a复制到b2.a,而且调用复制构造函数的时候，实参就是b1.a
 * */

#include <iostream>

using namespace std;

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


class B{
    A a;
};

int main()
{
    B b1, b2(b1);
    return 0;
}