C++ 继承详解：从概念到菱形继承

音草2026-10-19 10:47

文章目录

    • [1. 继承的概念及定义](#1. 继承的概念及定义)
      • [1.1 继承的概念](#1.1 继承的概念)
      • [1.2 继承定义](#1.2 继承定义)
        • [1.2.1 定义格式](#1.2.1 定义格式)
        • [1.2.2 继承基类成员访问方式的变化](#1.2.2 继承基类成员访问方式的变化)
      • [1.3 继承类模板](#1.3 继承类模板)
    • [2. 基类和派生类间的转换](#2. 基类和派生类间的转换)
    • [3. 继承中的作用域](#3. 继承中的作用域)
      • [3.1 隐藏规则](#3.1 隐藏规则)
      • [3.2 考察继承作用域相关选择题](#3.2 考察继承作用域相关选择题)
        • [3.2.1 A 和 B 类中的两个 func 构成什么关系（B）](#3.2.1 A 和 B 类中的两个 func 构成什么关系（B）)
        • [3.2.2 下面程序的编译运行结果是什么（A）](#3.2.2 下面程序的编译运行结果是什么（A）)
    • [4. 派生类的默认成员函数](#4. 派生类的默认成员函数)
      • [4.1 4 个常见默认成员函数](#4.1 4 个常见默认成员函数)
      • [4.2 实现一个不能被继承的类](#4.2 实现一个不能被继承的类)
    • [5. 继承与友元](#5. 继承与友元)
    • [6. 继承与静态成员](#6. 继承与静态成员)
    • [7. 多继承及其菱形继承问题](#7. 多继承及其菱形继承问题)
      • [7.1 继承模型](#7.1 继承模型)
      • [7.2 虚继承](#7.2 虚继承)
      • 7.3多继承中指针偏移问题
      • [7.4 IO库中的菱形虚拟继承](#7.4 IO库中的菱形虚拟继承)
    • 8.继承和组合
      • [8.1 继承和组合](#8.1 继承和组合)

1. 继承的概念及定义

1.1 继承的概念

继承（inheritance）机制是面向对象程序设计使代码可以复用最重要的手段，它允许我们在保持原有类特性的基础上进行扩展，增加方法（成员函数）和属性（成员变量），这样产生新的类，称派生类。

继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的是函数层次的复用，继承是类设计层次的复用。

下面我们看到没有继承之前我们设计了两个类 Student 和 Teacher，Student 和 Teacher 都有姓名/地址/电话/年龄等成员变量，都有 identity 身份认证的成员函数，设计到两个类里面就是冗余的。当然他们也有一些不同的成员变量和函数，比如老师独有成员变量是职称，学生的独有成员变量是学号；学生的独有成员函数是学习，老师的独有成员函数是授课。

cpp 复制代码 
class Student
{
public:
    // 进入校园/图书馆/实验室刷二维码等身份认证
    void identity()
    {
        // ...
    }
    // 学习
    void study()
    {
        // ...
    }
protected:
    string _name = "peter"; // 姓名
    string _address;        // 地址
    string _tel;            // 电话
    int _age = 18;          // 年龄
    int _stuid;             // 学号
};

class Teacher
{
public:
    // 进入校园/图书馆/实验室刷二维码等身份认证
    void identity()
    {
        // ...
    }
    // 授课
    void teaching()
    {
        //...
    }
protected:
    string _name = "张三";   // 姓名
    int _age = 18;          // 年龄
    string _address;        // 地址
    string _tel;            // 电话
    string _title;          // 职称
};

下面我们把公共的成员都放到 Person 类中，Student 和 Teacher 都继承 Person，就可以复用这些成员，就不需要重复定义了，省去了很多麻烦。

cpp 复制代码 
class Person
{
public:
    // 进入校园/图书馆/实验室刷二维码等身份认证
    void identity()
    {
        cout << "void identity()" << _name << endl;
    }
protected:
    string _name = "张三";  // 姓名
    string _address;        // 地址
    string _tel;            // 电话
    int _age = 18;          // 年龄
};

class Student : public Person
{
public:
    // 学习
    void study()
    {
        // ...
    }
protected:
    int _stuid;             // 学号
};

class Teacher : public Person
{
public:
    // 授课
    void teaching()
    {
        //...
    }
protected:
    string title;             // 职称
};

int main()
{
    Student s;
    Teacher t;
    s.identity();
    t.identity();
    return 0;
}

1.2 继承定义

1.2.1 定义格式

下面我们看到 Person 是基类，也称作父类。Student 是派生类，也称作子类。（因为翻译的原因，所以既叫基类/派生类，也叫父类/子类）

1.2.2 继承基类成员访问方式的变化
  1. 基类 private 成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
  2. 基类 private 成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为 protected。可以看出保护成员限定符是因继承才出现的。
  3. 实际上上面的表格我们进行一下总结会发现，基类的私有成员在派生类都是不可见。基类的其他成员在派生类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。
  4. 使用关键字 class 时默认的继承方式是 private，使用 struct 时默认的继承方式是 public，不过最好显式的写出继承方式。
  5. 在实际运用中一般使用都是 public 继承，几乎很少使用 protected/private 继承，也不提倡使用 protected/private 继承，因为 protected/private 继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。
cpp 复制代码 
// 实例演示三种继承关系下基类成员的各类型成员访问关系的变化
class Person
{
public:
    void Print()
    {
        cout << _name << endl;
    }
protected:
    string _name; // 姓名
private:
    int _age;     // 年龄
};

//class Student : protected Person
//class Student : private Person
class Student : public Person
{
protected:
    int _stunum; // 学号
};

1.3 继承类模板

cpp 复制代码 
namespace bit
{
    //template<class T>
    //class vector
    //{};
    // stack和vector的关系，既符合is-a，也符合has-a
    template<class T>
    class stack : public std::vector<T>
    {
    public:
        void push(const T& x)
        {
            // 基类是类模板时，需要指定一下类域，
            // 否则编译报错:error C3861: "push_back": 找不到标识符
            // 因为stack<int>实例化时，也实例化vector<int>了
            // 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到
            vector<T>::push_back(x);
            //push_back(x);
        }
        void pop()
        {
            vector<T>::pop_back();
        }
        const T& top()
        {
            return vector<T>::back();
        }
        bool empty()
        {
            return vector<T>::empty();
        }
    };
}

int main()
{
    bit::stack<int> st;
    st.push(1);
    st.push(2);
    st.push(3);
    while (!st.empty())
    {
        cout << st.top() << " ";
        st.pop();
    }
    return 0;
}

2. 基类和派生类间的转换

  • **public 继承的派生类对象可以赋值给基类的指针/基类的引用。**这里有个形象的说法叫切片或者切割。寓意把派生类中基类那部分切出来，基类指针或引用指向的是派生类中切出来的基类那部分。
  • 基类对象不能赋值给派生类对象。
  • **基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。**但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用 RTTI（Run-Time Type Information）的 dynamic_cast 来进行识别后进行安全转换。
cpp 复制代码 
class Person
{
protected:
    string _name; // 姓名
    string _sex;  // 性别
    int    _age;  // 年龄
};

class Student : public Person
{
public:
    int _No; // 学号
};

int main()
{
    Student sobj;
    // 1.派生类对象可以赋值给基类的指针/引用
    Person* pp = &sobj;
    Person& rp = sobj;
    // 派生类对象可以赋值给基类的对象是通过调用后面会讲解的基类的拷贝构造完成的
    Person pobj = sobj;
    // 2.基类对象不能赋值给派生类对象，这里会编译报错
    // sobj = pobj;
    return 0;
}

3. 继承中的作用域

3.1 隐藏规则

  1. 在继承体系中基类和派生类都有独立的作用域。
  2. **派生类和基类中有同名成员，派生类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。（**在派生类成员函数中，可以使用 基类::基类成员 显式访问）
  3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
  4. 注意在实际中在继承体系里面最好不要定义同名的成员。
cpp 复制代码 
// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
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;
}

3.2 考察继承作用域相关选择题

3.2.1 A 和 B 类中的两个 func 构成什么关系（B）

A. 重载　　B. 隐藏　　C. 没关系

3.2.2 下面程序的编译运行结果是什么（A）

A. 编译报错　　B. 运行报错　　C. 正常运行

cpp 复制代码 
class A
{
public:
    void fun()
    {
        cout << "func()" << endl;
    }
};

class B : public A
{
public:
    void fun(int i)
    {
        cout << "func(int i)" << i << endl;
    }
};

int main()
{
    B b;
    b.fun(10);
    // b.fun();  // 这里会编译报错，因为B中的fun(int)隐藏了A中的fun()
    return 0;
}

4. 派生类的默认成员函数

4.1 4 个常见默认成员函数

6 个默认成员函数，默认的意思就是指我们不写，编译器会帮我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？

  1. **派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。**如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显式调用。
  2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
  3. **派生类的 operator= 必须要调用基类的 operator= 完成基类的复制。**需要注意的是派生类的 operator= 隐藏了基类的 operator=，所以显式调用基类的 operator=，需要指定基类作用域。
  4. **派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。**因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
  5. 派生类对象初始化先调用基类构造再调派生类构造。
  6. 派生类对象析构清理先调用派生类析构再调基类的析构。
  7. 因为多态中一些场景析构函数需要构成重写，重写的条件之一是函数名相同。那么编译器会对析构函数名进行特殊处理，处理成 destructor()，所以基类析构函数不加 virtual 的情况下，派生类析构函数和基类析构函数构成隐藏关系。
cpp 复制代码 
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;
}

4.2 实现一个不能被继承的类

方法 1：基类的构造函数私有，派生类的构造必须调用基类的构造函数，但是基类的构造函数私有化以后，派生类看不见就不能调用了，那么派生类就无法实例化出对象。

方法 2：C++11 新增了一个 final 关键字，final 修饰基类，派生类就不能继承了。

cpp 复制代码 
// C++11的方法
class Base final
{
public:
    void func5() { cout << "Base::func5" << endl; }
protected:
    int a = 1;
private:
    // C++98的方法
    /*Base()
    {}*/
};

// class Derive : public Base  // 编译报错，无法继承final类
// {
//     void func4() { cout << "Derive::func4" << endl; }
// protected:
//     int b = 2;
// };

int main()
{
    Base b;
    // Derive d;
    return 0;
}

5. 继承与友元

友元关系不能继承，也就是说基类友元不能访问派生类私有和保护成员。

cpp 复制代码 
class Student;
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 成员
    // 解决方案：Display也变成Student的友元即可
}

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

6. 继承与静态成员

基类定义了 static 静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个派生类，都只有一个 static 成员实例。

cpp 复制代码 
class Person
{
public:
    string _name;
    static int _count;
};
int Person::_count = 0;

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

int main()
{
    Person p;
    Student s;
    // 这里的运行结果可以看到非静态成员_name的地址是不一样的
    // 说明派生类继承下来了，父派生类对象各有一份
    cout << &p._name << endl;
    cout << &s._name << endl;
    // 这里的运行结果可以看到静态成员_count的地址是一样的
    // 说明派生类和基类共用同一份静态成员
    cout << &p._count << endl;
    cout << &s._count << endl;
    // 公有的情况下，父派生类指定类域都可以访问静态成员
    cout << Person::_count << endl;
    cout << Student::_count << endl;
    return 0;
}

7. 多继承及其菱形继承问题

7.1 继承模型

  • 单继承：一个派生类只有一个直接基类时称这个继承关系为单继承。
  • 多继承：一个派生类有两个或以上直接基类时称这个继承关系为多继承，多继承对象在内存中的模型是，先继承的基类在前面，后面继承的基类在后面，派生类成员再放到最后面。
  • 菱形继承 ：菱形继承是多继承的一种特殊情况。菱形继承的问题，从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题，在 Assistant 的对象中 Person 成员会有两份。支持多继承就一定有菱形继承，像 Java 就直接不支持多继承，规避掉了这里的问题，所以实践中我们也是不建议设计出菱形继承这样的模型的。
cpp 复制代码 
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()
{
    // 编译报错：error C2385: 对"_name"的访问不明确
    Assistant a;
    // a._name = "peter";
    // 需要显式指定访问哪个基类的成员可以解决二义性问题，但是数据冗余问题无法解决
    a.Student::_name = "xxx";
    a.Teacher::_name = "yyy";
    return 0;
}

7.2 虚继承

很多人说 C++ 语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂，性能也会有一些损失，所以最好不要设计出菱形继承。多继承可以认为是 C++ 的缺陷之一，后来的一些编程语言都没有多继承，如 Java。

cpp 复制代码 
class Person
{
public:
    string _name; // 姓名
    // ...
};

// 使用虚继承Person类
class Student : virtual public Person
{
protected:
    int _num; // 学号
};

// 使用虚继承Person类
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;
 }

7.3多继承中指针偏移问题

下⾯说法正确的是( C)

A：p1 == p2 == p3 B：p1 < p2 < p3 C：p1 == p3 != p2 D：p1 != p2 != p3

cpp 复制代码 
1 class Base1 { public: int _b1; };
2 class Base2 { public: int _b2; };
3 class Derive : public Base1, public Base2 { public: int _d; };
4
5 int main()
6 {
7 Derive d;
8 Base1* p1 = &d;
9 Base2* p2 = &d;
10 Derive* p3 = &d;
11
12 return 0;
13 }

7.4 IO库中的菱形虚拟继承

代码演示：

cpp 复制代码 
 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>
{};

8.继承和组合

8.1 继承和组合

  • public继承是⼀种is-a的关系。也就是说每个派⽣类对象都是⼀个基类对象。

  • 组合是⼀种has-a的关系。假设B组合了A，每个B对象中都有⼀个A对象。

  • 继承允许你根据基类的实现来定义派⽣类的实现 。这种通过⽣成派⽣类的复⽤通常被称为⽩箱复⽤

    (white-box reuse)。术语"⽩箱"是相对可视性⽽⾔：在继承⽅式中，基类的内部细节对派⽣类可

    ⻅ 。继承⼀定程度破坏了基类的封装，基类的改变，对派⽣类有很⼤的影响。派⽣类和基类间的依

    赖关系很强，耦合度⾼。

  • 对象组合是类继承之外的另⼀种复⽤选择 。新的更复杂的功能可以通过组装或组合对象来获得。对

    象组合要求被组合的对象具有良好定义的接⼝。这种复⽤⻛格被称为⿊箱复⽤(black-box reuse)，

    因为对象的内部细节是不可⻅的。对象只以"⿊箱"的形式出现。 组合类之间没有很强的依赖关

    系，耦合度低。优先使⽤对象组合有助于你保持每个类被封装。

  • 优先使⽤组合，⽽不是继承 。实际尽量多去⽤组合，组合的耦合度低，代码维护性好。不过也不太

    那么绝对，类之间的关系就适合继承(is-a)那就⽤继承，另外要实现多态，也必须要继承。类之间的

    关系既适合⽤继承(is-a)也适合组合(has-a)，就⽤组合。

cpp 复制代码 
// Tire(轮胎)和Car(⻋)更符合has-a的关系
class Tire {
protected:
string _brand = "Michelin"; // 品牌
size_t _size = 17; // 尺⼨
};
class Car {
protected:
string _colour = "⽩⾊"; // 颜⾊
string _num = "陕ABIT00"; // ⻋牌号
Tire _t1; // 轮胎
Tire _t2; // 轮胎
Tire _t3; // 轮胎
Tire _t4; // 轮胎
};
class BMW : public Car {

 public:
 void Drive() { cout << "好开-操控" << endl; }
 };

 // Car和BMW/Benz更符合is-a的关系
 class Benz : public Car {
 public:
 void Drive() { cout << "好坐-舒适" << endl; }
 };

 template<class T>
 class vector
 {};

template<class T>
 class stack : public vector<T>
 {};

 template<class T>
 class stack
 {
 public:
 vector<T> _v;
 };

 int main()
 {
 return 0;
}
相关推荐
weixin_307779131 小时前
C++代码实现MATLAB中的spectralcluster函数功能
开发语言·c++·算法·matlab
xiaoye-duck2 小时前
《C++ 项目：手写大模型接入 SDK》Trae IDE 开发环境搭建与依赖管理
c++·ide·语言模型
沫璃染墨2 小时前
《Qt从零入门系列（十四）：QThread多线程详解——从线程创建到客户端阻塞处理》
开发语言·c++·笔记·qt·ui·交互·线程
草莓熊Lotso2 小时前
【C++ 基于微服务的即时通讯系统】Elasticsearch 从安装到 C++ 客户端二次封装全落地
linux·网络·数据库·c++·elasticsearch·微服务
CHPCWWHSU3 小时前
FreeCAD 源码解读：从 Property 到 Command，看一套 CAD 内核的完整闭环
c++·cad
代钦塔拉3 小时前
【C++/Qt 进阶】设计模式系列(5)：适配器模式——给“不兼容的接口“贴一层翻译膜
c++·qt·设计模式
aqiu1111113 小时前
蓝桥杯真题复盘：Fibonacci 数列与黄金分割（C++ 算法详解）
c++·算法·蓝桥杯
lojox3 小时前
C++ 手写 STL list（双向循环链表）原理剖析与实现
c++·链表·list
青少儿编程课堂3 小时前
蓝桥杯·全国青少年信息素养大赛·电子学会C/C++考级：拓扑排序课程表排课解析
c++·python·算法·bfs·信息学竞赛
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02「全语录+省流版」邵艾伦 × 孙宇晨：聊风口、聊个人IP、聊年轻人如何抓住 AI 时代的机会03如何新建文件夹？ 电脑新建文件夹的4种方法04GitHub 镜像站点05历年考研数学一、数学二、数学三真题试卷及答案PDF06几个好用的ip纯净度检测网站07蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接08Windows 10/11 如何退出微软账户并改用本地账户登录（含找不到选项的解决方法）09Telegram APK 下载安装完整指南 — 2026年最新10苹果iPA游戏软件资源下载网站