C++学习17派生类的构造函数

基类的构造函数不能被继承，在声明派生类时，对继承过来的成员变量的初始化工作也要由派生类的构造函数来完成。所以在设计派生类的构造函数时，不仅要考虑派生类新增的成员变量，还要考虑基类的成员变量，要让它们都被初始化。

解决这个问题的思路是：在执行派生类的构造函数时，调用基类的构造函数。

下面的例子展示了如何在派生类的构造函数中调用基类的构造函数。

#include<iostream>
using namespace std;
//基类
class People{
protected:
    char *name;
    int age;
public:
    People(char*, int);
};
People::People(char *name, int age): name(name), age(age){}
//派生类
class Student: public People{
private:
    float score;
public:
    Student(char*, int, float);
    void display();
};
//调用了基类的构造函数
Student::Student(char *name, int age, float score): People(name, age){
    this->score = score;
}
void Student::display(){
    cout<<name<<"的年龄是"<<age<<"，成绩是"<<score<<endl;
}
int main(){
    Student stu("小明", 16, 90.5);
    stu.display();
    return 0;
}

请注意代码第23行：

Student::Student(char *name, int age, float score): People(name, age)

这是派生类 Student 的构造函数的写法。冒号前面是派生类构造函数的头部，这和我们以前介绍的构造函数的形式一样，但它的形参列表包括了初始化基类和派生类的成员变量所需的数据；冒号后面是对基类构造函数的调用，这和普通构造函数的参数初始化表非常类似。

实际上，你可以将对基类构造函数的调用和参数初始化表放在一起，如下所示：

Student::Student(char *name, int age, float score): People(name, age), score(score){}

基类构造函数和初始化表用逗号隔开。

需要注意的是：冒号后面是对基类构造函数的调用，而不是声明，所以括号里的参数是实参，它们不但可以是派生类构造函数总参数表中的参数，还可以是局部变量、常量等。如下所示：

Student::Student(char *name, int age, float score): People("李磊", 20)

基类构造函数调用规则

事实上，通过派生类创建对象时必须要调用基类的构造函数，这是语法规定。也就是说，定义派生类构造函数时最好指明基类构造函数；如果不指明，就调用基类的默认构造函数（不带参数的构造函数）；如果没有默认构造函数，那么编译失败。

请看下面的例子：

#include<iostream>
using namespace std;
//基类
class People{
protected:
    char *name;
    int age;
public:
    People();
    People(char*, int);
};
People::People(){
    this->name = "xxx";
    this->age = 0;
}
People::People(char *name, int age): name(name), age(age){}
//派生类
class Student: public People{
private:
    float score;
public:
    Student();
    Student(char*, int, float);
    void display();
};
Student::Student(){
    this->score = 0.0;
}
Student::Student(char *name, int age, float score): People(name, age){
    this->score = score;
}
void Student::display(){
    cout<<name<<"的年龄是"<<age<<"，成绩是"<<score<<endl;
}
int main(){
    Student stu1;
    stu1.display();
    Student stu2("小明", 16, 90.5);
    stu2.display();
    return 0;
}

创建对象 stu1 时，执行派生类的构造函数 Student::Student()，它并没有指明要调用基类的哪一个构造函数，从运行结果可以很明显地看出来，系统默认调用了不带参数的构造函数，也就是 People::People()。

创建对象 stu2 时，执行派生类的构造函数 Student::Student(char *name, int age, float score)，它指明了基类的构造函数。

在第31行代码中，如果将 People(name, age) 去掉，也会调用默认构造函数，stu2.display() 的输出结果将变为：
xxx的年龄是0，成绩是90.5

如果将基类 People 中不带参数的构造函数删除，那么会发生编译错误，因为创建对象 stu1 时没有调用基类构造函数。

总结：如果基类有默认构造函数，那么在派生类构造函数中可以不指明，系统会默认调用；如果没有，那么必须要指明，否则系统不知道如何调用基类的构造函数。

构造函数的调用顺序

为了搞清这个问题，我们不妨先来看一个例子：

#include<iostream>
using namespace std;
//基类
class People{
protected:
    char *name;
    int age;
public:
    People();
    People(char*, int);
};
People::People(): name("xxx"), age(0){
    cout<<"PeoPle::People()"<<endl;
}
People::People(char *name, int age): name(name), age(age){
    cout<<"PeoPle::People(char *, int)"<<endl;
}
//派生类
class Student: public People{
private:
    float score;
public:
    Student();
    Student(char*, int, float);
};
Student::Student(): score(0.0){
    cout<<"Student::Student()"<<endl;
}
Student::Student(char *name, int age, float score): People(name, age), score(score){
    cout<<"Student::Student(char*, int, float)"<<endl;
}
int main(){
    Student stu1;
    cout<<"--------------------"<<endl;
    Student stu2("小明", 16, 90.5);
    return 0;
}

从运行结果可以清楚地看到，当创建派生类对象时，先调用基类构造函数，再调用派生类构造函数。如果继承关系有好几层的话，例如：

A --> B --> C

那么则创建C类对象时，构造函数的执行顺序为：

A类构造函数 --> B类构造函数 --> C类构造函数

构造函数的调用顺序是按照继承的层次自顶向下、从基类再到派生类的。