1.继承的概念及定义

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保
持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象
程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继
承是类设计层次的复用。

基类（父类）：被继承的类，提供公共的属性和方法。
派生类（子类）：继承基类的类，可以复用基类功能，也能扩展新功能。

2、继承的语法

// 基类
class 基类名 {
    // 成员
};

// 派生类：继承方式 基类名
class 派生类名 : 继承方式 基类名 {
    // 新增成员
};

3.继承方式

决定了基类成员在派生类中的访问权限：

继承方式	基类public成员	基类protected成员	基类private成员
公有继承（public）	仍为public	仍为protected	不可直接访问
保护继承（protected）	变为protected	变为protected	不可直接访问
私有继承（private）	变为private	变为private	不可直接访问

 

4.完整演示

我们用 Person（人）作为基类，Student（学生）作为派生类演示：

#include <iostream>
#include <string>
using namespace std;

// 基类：人类
class Person {
// 受保护权限：子类可以访问，外部不能访问
protected:
    string name;
    int age;

public:
    // 基类构造函数
    Person(string n, int a) : name(n), age(a) {}

    // 公共方法
    void showInfo() {
        cout << "姓名：" << name << "，年龄：" << age << endl;
    }
};

// 派生类：学生类  公有继承 Person
class Student : public Person {
private:
    // 子类新增成员
    int studentId;

public:
    // 子类构造函数：必须先调用基类构造函数
    Student(string n, int a, int id) : Person(n, a), studentId(id) {}

    // 子类新增方法
    void study() {
        // 直接使用基类的 protected 成员
        cout << name << "正在学习，学号：" << studentId << endl;
    }
};

int main() {
    // 创建子类对象
    Student s("张三", 20, 1001);
    
    // 调用继承自基类的方法
    s.showInfo();
    
    // 调用子类自己的方法
    s.study();

    return 0;
}

5.基类和派生类对象赋值转换

在 C++ 公有继承 下，基类和派生类的对象、指针、引用可以进行赋值转换，这是面向对象中向上转型的基础，也是多态的前提！

只有 公有继承（public） 才能做这种赋值转换，保护 / 私有继承会因为权限问题直接报错。

我们沿用 Person（基类）、Student（派生类）举例：

#include <iostream>
#include <string>
using namespace std;

// 基类
class Person {
protected:
    string name;
public:
    Person(string n) : name(n) {}
    void show() { cout << "人：" << name << endl; }
};

// 派生类（公有继承）
class Student : public Person {
private:
    int id; // 派生类独有成员
public:
    Student(string n, int i) : Person(n), id(i) {}
    void study() { cout << name << " 学习，学号：" << id << endl; }
};

1. 基类对象 = 派生类对象（对象赋值）

派生类赋值给基类对象时，会发生 切片（截断）：
只拷贝基类的成员，派生类独有的成员会被切掉，基类对象无法访问派生类新增成员。

int main() {
    Student s("张三", 1001); 
    Person p = s;  // ✅ 合法：派生类 → 基类对象
    p.show();      // 正常调用基类方法
    // p.study();  // ❌ 报错！切片后丢失了派生类的成员和方法
    return 0;
}

2. 基类引用 = 派生类对象（推荐，无切片）

基类引用可以直接绑定派生类对象，不发生拷贝，无切片，效率更高！

Student s("李四", 1002);
Person& ref = s; // ✅ 合法：基类引用绑定派生类对象
ref.show();      // 调用基类方法
// ref.study();  // ❌ 报错！引用类型是基类，无法访问派生类独有方法

3. 基类指针 = 派生类对象地址（最常用，多态基础）

基类指针可以直接指向派生类对象，无切片，是 C++ 多态的核心用法！

Student s("王五", 1003);
Person* ptr = &s; // ✅ 合法：基类指针指向派生类对象
ptr->show();      // 调用基类方法
// ptr->study(); // ❌ 报错！指针类型是基类，无法访问派生类独有方法

4.反向赋值（绝对不允许）

基类对象 不能 赋值给派生类对象 / 引用 / 指针！
原因：基类没有派生类的独有成员，会导致数据缺失，编译直接报错。

Person p("赵六");
// Student s = p;     // ❌ 报错
// Student& ref = p;  // ❌ 报错
// Student* ptr = &p; // ❌ 报错

总结：

公有继承下：
派生类对象 → 基类对象 / 引用 / 指针：自动安全，向上转型
对象赋值会切片，指针 / 引用无切片
基类对象 → 派生类：直接报错，禁止使用
基类指针 / 引用指向派生类是 C++ 多态的基础