封闭类：

有成员对象的类叫 封闭（enclosing)类。

示例：

#include <iostream>

using namespace std;

class CTyre //轮胎类
{
	public:
		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 );
		
		void printa(); 
};

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

void CCar::printa(){
	cout<<this->price<<endl;
	cout<<this->tyre.radius<<endl;
	cout<<this->tyre.width<<endl;       //利用this指针作用于该对象
}  

int main()
{
	CCar car(20000,17,225); 
	car.printa();
	return 0;
}
/*输出结果:
20000
17
225
*/

注：如果 CCar类不定义构造函数， 则下面的语句会编译出错：

CCar car;

因为编译器不明白 car.tyre该如何初始化。car.engine 的初始化没问题，用默认构造函数即可。
成员对象初始化列表中的参数可以是任意复杂的表达式，可以包括函数，变量，只要表达式中的函数或变量有定义就行。

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

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

示例：

#include <iostream>

using namespace std;
class CTyre {
	public:
		CTyre() { cout << "CTyre 建立" << endl; }
		
		~CTyre() { cout << "CTyre 消亡" << endl; }
};



class CEngine {
	public:
		CEngine() { cout << "CEngine 建立" << endl; }
		~CEngine() { cout << "CEngine 消亡" << endl; }
};


class CCar {
	private:
		CEngine engine; 
		CTyre tyre;
	public:
		CCar( ) { cout << "CCar 建立" << endl; }
		~CCar() { cout << "CCar 消亡" << endl; }
};

int main(){
	CCar car; 
	return 0;
}
/*
输出结果：
CEngine 建立
CTyre 建立
CCar 建立
CCar 消亡
CTyre 消亡
CEngine 消亡
*/

封闭类的复制构造函数：

#include <iostream>

using namespace std;

class A
{
	public:
		A() { cout << "default" << endl; }
		A(A & a) { cout << "copy" << endl;}  //类A的复制构造函数
};
class B { A a; };


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

/*
输出结果：
default
copy
*/

注意：输出结果说明:说明b2.a是用类A的复制构造函数初始化的。而且调用复制构造函数时的实参就是b1.a。