转载：https://blog.csdn.net/qq1169091731/article/details/50934588?utm_source=blogxgwz6

类的数据成员不但可以是标准型（如int、char）或系统提供的类型（如string），还可以包含类对象，如可以在声明一个类时包含这样的数据成员：

class B{
…
}；
class A{
public:
     B s1;  //B是已声明的类名，s1是B类的对象
    …
 }；

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

这时，s1就是类对象中的内嵌对象，称为子对象(subobject)，即对象中的对象。
在派生类中，子对象为基类在派生类中定义的对象。如下列代码：

class Student{
…
};
class Student1:public Student{
private:
      Student a;              //这里的a即为子对象
      …
}；

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

通过例子来说明问题。在上篇博客（C++派生类的构造函数）中的派生类Student1中，除了可以在派生类中要增加数据成员age和address外，还可以增加“班长”一项，即学生数据中包含他们的班长的姓名和其他基本情况，而班长本身也是学生，他也属于Student类型，有学号和姓名等基本数据，这样班长项就是派生类Student1中的子对象。在下面程序的派生类的数据成员中， 有一项monitor(班长)，它是基类Student的对象，也就是派生类Student1的子对象。

那么，在对数据成员初始化时怎样对子对象初始化呢？请仔细分析下面程序，特别注意派生类构造函数的写法。
[例11.6] 包含子对象的派生类的构造函数。为了简化程序

以易于阅读，这里设基类Student的数据成员只有两个，即num和name。

#include <iostream>
#include <string>
using namespace std;
class Student//声明基类
{
public: //公用部分
   Student(int n, string nam ) //基类构造函数，与例11.5相同
   {
      num=n;
      name=nam;
   }
   void display( ) //成员函数，输出基类数据成员
   {
      cout<<"num:"<<num<<endl<<"name:"<<name<<endl;
   }
protected: //保护部分
   int num;
   string name;
};
class Student1: public Student //声明公用派生类Student1
{
public:
   Student1(int n, string nam,int n1, string nam1,int a, string ad):Student(n,nam),monitor(n1,nam1) //派生类构造函数
   {
      age=a;
      addr=ad;
   }
   void show( )
   {
      cout<<"This student is:"<<endl;
      display(); //输出num和name
      cout<<"age: "<<age<<endl; //输出age
      cout<<"address: "<<addr<<endl<<endl; //输出addr
   }
   void show_monitor( ) //成员函数，输出子对象
   {
      cout<<endl<<"Class monitor is:"<<endl;
      monitor.display( ); //调用基类成员函数
   }
private: //派生类的私有数据
   Student monitor; //定义子对象(班长)
   int age;
   string addr;
};
int main( )
{
   Student1 stud1(10010,"Wang-li",10001,"Li-sun",19,"115 Beijing Road,Shanghai");
   stud1.show( ); //输出学生的数据
   stud1.show_monitor(); //输出子对象的数据
   return 0;
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51

运行时的输出如下：

This student is:
num: 10010
name: Wang-li
age: 19
address:115 Beijing Road,Shanghai
Class monitor is:
num:10001
name:Li-sun

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

请注意在派生类Student1中有一个数据成员：
Student monitor; //定义子对象 monitor(班长)

“班长”的类型不是简单类型(如int、char、float等)，它是Student类的对象。我们知道， 应当在建立对象时对它的数据成员初始化。那么怎样对子对象初始化呢？显然不能在声明派生类时对它初始化（如Student monitor(10001, “Li-fun”);），因为类是抽象类型，只是一个模型，是不能有具体的数据的，而且每一个派生类对象的子对象一般是不相同的（例如学生A、B、C的班长是A，而学生D、E、F的班长是F）。因此子对象的初始化是在建立派生类时通过调用派生类构造函数来实现的。

派生类构造函数的任务应该包括3个部分:

对基类数据成员初始化；
对子对象数据成员初始化；
对派生类数据成员初始化。

• 1
• 2
• 3

程序中派生类构造函数首部如下：
Student1(int n, string nam,int n1, string nam1,int a, string ad):
Student(n,nam),monitor(n1,nam1)
在上面的构造函数中有6个形参，前两个作为基类构造函数的参数，第3、第4个作为子对象构造函数的参数，第5、第6个是用作派生类数据成员初始化的。

归纳起来，定义派生类构造函数的一般形式为：
派生类构造函数名(总参数表列): 基类构造函数名(参数表列), 子对象名(参数表列)
{
派生类中新增数成员据成员初始化语句
}

执行派生类构造函数的顺序是：

调用基类构造函数，对基类数据成员初始化；
调用子对象构造函数，对子对象数据成员初始化；
再执行派生类构造函数本身，对派生类数据成员初始化。

• 1
• 2
• 3

派生类构造函数的总参数表列中的参数，应当包括基类构造函数和子对象的参数表列中的参数。基类构造函数和子对象的次序可以是任意的，如上面的派生类构造函数首部可以写成
Student1(int n, string nam,int n1, string nam1,int a, string ad): monitor(n1,nam1),Student(n,nam)
编译系统是根据相同的参数名(而不是根据参数的顺序)来确立它们的传递关系的。但是习惯上一般先写基类构造函数。

如果有多个子对象，派生类构造函数的写法依此类推，应列出每一个子对象名及其参数表列。