C++ 继承详解：派生类函数、虚继承原理与菱形继承案例 | 极客日志

C++算法

C++ 继承详解：派生类函数、虚继承原理与菱形继承案例

综述由AI生成深入讲解了 C++ 继承的核心机制。内容涵盖继承的概念与定义，详细分析了 public、protected、private 三种继承方式对访问权限的影响。探讨了派生类默认成员函数的生成与调用顺序，特别是构造函数与析构函数的执行流程。重点剖析了多继承中的菱形继承问题，解释了数据冗余和二义性的成因，并展示了虚继承的解决方案及 STL IO 库中的应用实例。最后对比了继承与组合的区别，强调在满足 is-a 关系或多态需求时使用继承，而在其他场景优先选择组合以降低耦合度。

KernelLab发布于 2026/3/15更新于 2026/5/56 浏览

C++ 继承详解：派生类函数、虚继承原理与菱形继承案例

继承的概念与定义

继承（Inheritance）是面向对象程序设计中实现代码复用的核心机制。它允许我们在保留基类特性的基础上进行扩展，增加新的成员函数或属性，从而生成新的派生类。这种机制体现了由简单到复杂的认知过程，将类设计层次的复用提升到了新的高度。

概念解析

假设我们有两个类 Student 和 Teacher，它们都有公共的成员如姓名、电话、地址等，以及身份认证的功能。如果分别定义这些成员，会造成冗余。更好的做法是将公共部分封装到一个基类 Person 中，让 Student 和 Teacher 通过继承来复用这些成员。

class Person {
public:
    // 身份识别，比如进入图书馆打卡
    void Identify() {
        cout << "void Identify()" << _name << endl;
    }
protected:
    string _name;      // 名字
    string _tel;       // 电话
    string _address;   // 地址
    int _age;          // 年龄
};

class Student : public Person {
public:
    void study() { /* ... */ }
protected:
    int _stuid;        // 学号 <- 学生特有
};

class Teacher : public Person {
public:
    void teaching() { /* ... */ }
protected:
    string _title;     // 职称 <- 教师特有
};

继承的定义与方式

在 C++ 中，基类也称为父类，派生类也称为子类。继承方式主要有三种：public、protected 和 private。

class Person {
public:
    void Print() { cout << _name << endl; }
protected:
    string _name = "1";
private:
    int _age;
};

class Student : public Person {
protected:
    int _stunum;
};

int main() {
    Student s;
    s.Print(); // 可访问
    return 0;
}

class Student : protected Person {
    // ...
};

class Student : private Person {
    // ...
};

template<class T>
class Stack : public vector<T> {
public:
    void push(const T& x) {
        vector<T>::push_back(x); // 必须指定作用域
    }
    void pop() {
        vector<T>::pop_back();
    }
};

class Person {
protected:
    string _name;
    int _age;
};

class Student : public Person {
public:
    int _No;
};

int main() {
    Student s;
    Person* ptr = &s; // 合法，切片
    Person& a = s;    // 合法
    Person per = s;   // 调用拷贝构造，发生切片
    // s = per;       // 错误，基类对象不能赋值给派生类对象
    return 0;
}

class Person {
protected:
    string _name = "小李";
    int _num = 111;
};

class Student : public Person {
public:
    void Print() {
        cout << "姓名:" << _name << endl;
        cout << "身份证号:" << Person::_num << endl; // 显式访问基类成员
        cout << "学号:" << _num << endl;
    }
protected:
    int _num = 999;
};

int main() {
    Student s1;
    s1.Print();
    return 0;
}

class Person {
public:
    Person(const char* name = "peter") : _name(name) {
        cout << "Person()" << endl;
    }
    Person(const Person& p) : _name(p._name) {
        cout << "Person(const Person& p)" << endl;
    }
    Person& operator=(const Person& p) {
        cout << "Person operator=(const Person& p)" << endl;
        if (this != &p) _name = p._name;
        return *this;
    }
    ~Person() {
        cout << "~Person()" << endl;
    }
protected:
    string _name;
};

class Student : public Person {
public:
    Student(const char* name, int num) : Person(name), _num(num) {
        cout << "Student()" << endl;
    }
    Student(const Student& s) : Person(s), _num(s._num) {
        cout << "Student(const Student& s)" << endl;
    }
    Student& operator=(const Student& s) {
        cout << "Student& operator= (const Student& s)" << endl;
        if (this != &s) {
            Person::operator=(s); // 显式调用基类赋值
            _num = s._num;
        }
        return *this;
    }
    ~Student() {
        cout << "~Student()" << endl;
    }
protected:
    int _num;
};

int main() {
    Student s1("jack", 18);
    Student s2(s1);
    Student s3("rose", 17);
    s1 = s3;
    return 0;
}

class Base final {
public:
    void func5() { cout << "Base::func5" << endl; }
protected:
    int a = 1;
private:
};

class Derive : public Base { // 编译报错：Derive 不能继承 final 类
    void func4() { cout << "Derive::func4" << endl; }
};

class Person {
public:
    friend void Display(const Person& p, const Student& s);
protected:
    string _name;
};

class Student : public Person {
protected:
    int _stuNum;
};

void Display(const Person& p, const Student& s) {
    cout << p._name << endl;
    cout << s._stuNum << endl; // 编译报错：无法访问 protected 成员
}

int main() {
    Person p;
    Student s;
    Display(p, s);
    return 0;
}

class Person {
public:
    string _name;
};

class Student : public Person {
protected:
    int _num;
};

class Teacher : public Person {
protected:
    int _id;
};

class Assistant : public Student, public Teacher {
protected:
    string _majorCourse;
};

int main() {
    Assistant a;
    // a._name = "peter"; // 编译报错：访问不明确
    a.Student::_name = "xxx"; // 解决二义性，但数据冗余无法解决
    a.Teacher::_name = "yyy";
    return 0;
}

class Person {
public:
    string _name;
};

class Student : virtual public Person {
protected:
    int _num;
};

class Teacher : virtual public Person {
protected:
    int _id;
};

class Assistant : public Student, public Teacher {
protected:
    string _majorCourse;
};

int main() {
    Assistant a;
    a._name = "peter"; // 正常访问，无二义性，无冗余
    return 0;
}

template<class CharT, class Traits = std::char_traits<CharT>>
class basic_ostream : virtual public std::basic_ios<CharT, Traits> {};

template<class CharT, class Traits = std::char_traits<CharT>>
class basic_istream : virtual public std::basic_ios<CharT, Traits> {};