C++<第二十一篇>：继承

继承是面向对象的主要特征之一，它使得一个类可以从现有类中派生，而不必重新定义一个新类。
继承的实质就是用已有数据类型创建新的数据类型，并保留已有数据类型的特点，以旧类为基础创建新类，新类包含了旧类的成员变量和成员函数，并且可以在新类中添加新的成员变量和成员函数。
旧类被称为基类或者父类，新类被称为派生类或者子类。

（1）类继承的一般格式

class 派生类名: [继承方式] 基类名
{
    成员...
}

派生类又称子类，基类又称父类，所以以下的格式和前者是一致的：

class 子类类名: [继承方式] 父类名
{
    成员...
}

继承方式有三种，分别是公有型（public）、保护型（protected）和私有型（private）。

（2）继承的使用

假设有一个 Pesonal（人）对象，Pesonal有姓名和年龄两个属性：

class Pesonal 
{
private:
    string mName; // 姓名
    int mAge; // 年龄

public:
    void setName(string name) 
    {
        mName = name;
    }

    string getName() 
    {
        return mName;
    }

    void setAge(int age) 
    {
        mAge = age;
    }

    int getAge() 
    {
        return mAge;
    }
};

还有一个Student（学生）对象，Student有姓名、年龄、成绩三个属性：

class Student
{
private:
    string mName; // 姓名
    int mAge; // 年龄
    int16_t mScore; // 成绩

public:
    void setName(string name)
    {
        mName = name;
    }

    string getName()
    {
        return mName;
    }

    void setAge(int age)
    {
        mAge = age;
    }

    int getAge()
    {
        return mAge;
    }

    void setScore(int score) 
    {
        mScore = score;
    }

    int getScore() 
    {
        return mScore;
    }
};

学生也是人，因此学生也有人的特性，Student也具有Pesonal的姓名和年龄两种属性，所以，这两个类可以使用继承关系。
我们需要对Student类做下修改，代码如下：

class Student:public Pesonal
{
private:
    int16_t mScore; // 成绩

public:

    void setScore(int score) 
    {
        mScore = score;
    }

    int getScore() 
    {
        return mScore;
    }
};

Student类中，只要添加Student特有的属性即可，Student可以使用Pesonal中的属性。

使用代码如下：

Student student;
student.setName("zhangsan");
student.setAge(16);
student.setScore(90);

cout << "姓名：" << student.getName() << endl;
cout << "年龄：" << student.getAge() << endl;
cout << "成绩：" << student.getScore() << endl;

（2）访问控制和继承

派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问，则应在基类中声明为 private。

我们可以根据访问权限总结出不同的访问类型，如下所示：

访问	public	protected	private
同一个类	yes	yes	yes
派生类（子类）	yes	yes	no
外部的类	yes	no	no

一个派生类继承了所有的基类方法，但下列情况除外：

基类的构造函数、析构函数和拷贝构造函数。
基类的重载运算符。
基类的友元函数。
继承方式

（3）继承方式

继承方式有 public、private、protected 3种，3种继承方式说明如下：

我们几乎不使用 protected 或 private 继承，通常使用 public 继承。当使用不同类型的继承时，遵循以下几个规则：

公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
保护继承（protected）：当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。

（4）构造函数和析构函数的访问顺序

为了方便研究派生类和基类构造函数和析构函数的调用顺序，需要写一个演示代码：

#include <iostream>
#include <string>

using namespace std;

class Pesonal 
{
private:
    string mName; // 姓名
    int mAge; // 年龄

public:
    Pesonal() 
    {
        cout << "构造函数 --- Pesonal" << endl;
    }
    ~Pesonal() 
    {
        cout << "析构函数 --- Pesonal" << endl;
    }

    void setName(string name) 
    {
        mName = name;
    }

    string getName() 
    {
        return mName;
    }

    void setAge(int age) 
    {
        mAge = age;
    }

    int getAge() 
    {
        return mAge;
    }
};

class Student:public Pesonal
{
private:
    int16_t mScore; // 成绩

public:
    Student()
    {
        cout << "构造函数 --- Student" << endl;
    }
    ~Student()
    {
        cout << "析构函数 --- Student" << endl;
    }
    void setScore(int score) 
    {
        mScore = score;
    }

    int getScore() 
    {
        return mScore;
    }
};

int main()
{
    Student student;
    student.setName("zhangsan");
    student.setAge(16);
    student.setScore(90);

    cout << "姓名：" << student.getName() << endl;
    cout << "年龄：" << student.getAge() << endl;
    cout << "成绩：" << student.getScore() << endl;

    return 0;
}

在运用时，我们只创建了派生类对象，调用后的输出结果是：

构造函数 --- Pesonal
构造函数 --- Student
姓名：zhangsan
年龄：16
成绩：90
析构函数 --- Student
析构函数 --- Pesonal

所以，构造函数的调用顺序是：

基类（父类）  -->     派生类（子类）

析构函数的调用顺序和构造函数相反：

派生类（子类）  -->   基类（父类）

（5）子类显式调用父类的构造函数

当子类实例化时，子类和父类的构造函数都会被执行；
子类执行哪个构造函数取决于子类实例化传入的参数；
那么，到底执行了父类的哪个构造函数呢？

一般情况下，默认调用父类没有形式参数的构造方法，如果想要调用父类有形式参数的构造方法，我们需要显式调用父类的构造函数，代码如下：

Pesonal类的带参构造方法：

Pesonal(string name, int age)
{
    mName = name;
    mAge = age;
}

Student类的无参构造方法：

Student() :Pesonal("zhangsan", 16)
{
    
}

此时，先调用Pesonal类的带参构造方法，再调用Student类的无参构造方法。

（6）上转型对象

上转型其实就是子类转成父类，我们先看下代码：

Student student;
student.setName("zhangsan");
student.setAge(16);
student.setScore(90);

Pesonal pesonal = student; // 上转型，子类转成父类

cout << "姓名：" << pesonal.getName() << endl;
cout << "年龄：" << pesonal.getAge() << endl;

Student有一个属性：成绩，由于Student继承Pesonal，相当于Student有三个属性：姓名、年龄、成绩；
Pesonal只有两个属性：姓名、年龄；
当Student赋值给Pesonal时，即：

Pesonal pesonal = student; // 上转型，子类转成父类

pesonal只能访问Pesonal类中的成员，不能访问Student中的成员。

如果需要父类转成子类，这样的转换属于降级转换，降级转换必须使用强制转换，父类转子类的强制转换和上转型相反。

（7）多重继承

C++可以多重继承，多重继承的一般形式为：

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
    <派生类类体>
};

多个基类用逗号隔开。

子类可以调用多个父类的公有型和保护型的成员。

[本章完...]