C++：类的组合

在类中定义的数据成员一般都是基本数据类型或服复合数据类型。但是还可以根据需要使用
其他类的对象作为正在声明的数据成员。复杂的对象还可以有比较简单的对象一某种方式组合
而成，复杂对象和组成它的简单对象之间的关系是组合关系。

在一个类中内嵌另一个类的对象作为数据成员，称为类的组合。该内嵌对象称为对象成员，也称为
子对象。例如：

class A
{
.......
};
class B
{
A a; //类A的对象a为类B的对象成员
public:
....
};

当创建类的对象时，如果这个类具有内嵌对象成员，那么内嵌对象成员也将被自动创建，因此，
在创建对象时既要对本类的基本数据成员初始化，又要对内嵌的对象成员进行初始化。含有对象
成员的类，其构造函数和不含对象成员的构造函数有所不同，例如有以下的类X：
class X{
类名1 对象成员 1；
类名2 对象成员 2；
.................
类名n 对象成员 n；
};

一般来说，类X的构造函数的定义形式为：
X::X(形参表0):对象成员1(形参表1),对象成员2(形参表2),对象成员3(形参表3),....
{
//类的构造函数体
}

其中，"对象成员1(形参表1),对象成员2(形参表2),对象成员3(形参表3),...."称作初始化表，其作用
是对对象成员进行初始化。
当调用构造函数X::X()时，首先按各内嵌对象成员在类声明中的顺序依次调用他们的构造函数，对这些
对象初始化。最后在执行类X的构造函数体，初始化类X的其他成员。析构函数的调用顺序与构造函数的
调用顺序相反。

例： 对象成员的初始化

#include<iostream>
using namespace std;
class A{               //声明类A
public:
A(int x1,float y1)
{
x = x1;
y = y1;
}
void show()
{
cout<<"x="<<x<<endl;
cout<<"y="<<y<<endl;
}
private:
int x;
float y;
};
class B{           //声明类B
public:
B(int x1,float y1,int z1):a(x1,y1)   //类B的构造函数，含有初始化列表，用与对内嵌对象a进行初始化
{
z = z1;
}
void show()
{
a.show();
cout<<"z="<<z<<endl;
}
private:
A a;      //类A的对象a为类B的对象成员
int z;
};
int main()
{
B b(11,22,33);
b.show();

return 0;
}

需求：定义学生类和成绩类，将student类的成员score作为成绩类的一个对象 ，然后用初始化
列表进行初始化。
例 ：对象成员的应用

#include<iostream>
#include<string>
using namespace std;
class Score{            //声明类Score
public:
Score(float m,float l,float E);
void show();
private:
float math;
float language;
float English;
};
Score::Score(float m,float l,float E)     //定义构造函数
{
math = m;
language = l;
English = E;
}
void Score::show()
{
cout<<"数学的成绩是："<<math<<endl;
cout<<"语文的成绩是："<<language<<endl;
cout<<"英语的成绩是："<<English<<endl;
}
class Student{                     //声明类student
public:
Student(char* n,char* s,float m,float l,float E);   //声明构造函数
~Student();  //声明析构函数
void show();
private:
char* name;     //学生姓名
char* sno;      //学生学号
Score Sco;      //对象成员，是类Score的对象
};
Student::Student(char* n,char* s,float m,float l,float E):Sco(m,l,E)  //定义构造函数
{
name = new char[strlen(n)+1];
strcpy(name,n);
sno = new char[strlen(n)+1];
strcpy(sno,s);
}
Student::~Student()
{
delete []name;
delete []sno;
}
void Student::show()
{
cout<<"学生的姓名是："<<name<<endl;
cout<<"学生的学号是："<<sno<<endl;
Sco.show();
}
int main()
{
Student stu1("张三","1011",98.3,98.6,99.1); //定义类student的对象stu1,调用stu1的构造函数,
//初始化对象stu1
stu1.show();  //调用stu1的show(),显示stu1的数据
cout<<endl;

Student stu2("李四","1012",98.8,98.5,99.5);
stu2.show();
cout<<endl;
}

从上面的程序可以看出，类student的show函数中对于对象成员Sco的处理方式就是通过调用类Score的show函数
来实现的。

说明：
1、声明含有对象的类，首先要创建对象成员。本例在声明类Studet中，定义了对象成员Sco；
Score Sco；

2、在定义类Student的对象，调用构造函数进行初始化的同时，也要对对象成员进行初始化，因为它
属于此类的成员。因此在写类Student的构造函数时，也缀上了对象成员Sco要调用类Score的构造
函数。
Student::Student(char* n,char* s,float m,float l,float E):Sco(m,l,E){}
这时构造函数的调用顺序是：先调用对象成员Sco的构造函数，对对象成员的数据成员进行初始化。
随后再执行类Student的构造函数的函数体，对派生类数据成员进行初始化。

注意：在定义类Student的构造函数时，必须缀上对象成员的名字Sco，而不能缀上类名。。。