成员对象和封闭类

1、定义

成员对象：一类的成员变量是另一个类的对象
封闭类：包含成员对象的类

2、初始化列表

定义封闭类的构造函数时，添加初始化列表：
类名：：构造函数（参数表）：成员变量1（参数表），成员变量2（参数表）{ …….}
成员对象初始化列表中的参数：

• 任意复杂的表达式
• 函数/变量/表达式中的变量、函数有定义

#include<stdio.h>
#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;
        cengine engine;
    public:
        ccar(int p,int tr,int w):price(p),tyre(tr,w){

        }
};
int main()
{
    ccar car(1,2,3);
    return 0;
}

3、构造函数执行顺序

• 当封闭类对象生成时
  
  • 首先，执行所有成员对象的构造函数
  • 然后，执行封闭类的构造函数

• 成员对象的构造函数调用顺序

  • 和成员对象在类中的说明顺序一致
  • 与在成员初始化列表中出现的顺序无关

• 当封闭类的对象消亡时

  • 先执行封闭类的析构函数
  • 然后执行成员对象的析构函数

#include<stdio.h>
#include<iostream>
using namespace std;
class ctyre{
    private :
        int radius;
        int width;
    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:
        ctyre tyre;
        cengine engine;
    public:
        ccar(){
            cout<<"ccar constructor"<<endl;
        }
        ~ccar(){
            cout<<"ccar destructor"<<endl;
        }
};
int main()
{
    ccar car;
    return 0;
}

程序结果：

ctyre constructor
cengine constructor
ccar constructor
ccar destructor
cengine destructor
ctyre destructor