c++之多态（揭秘多态：面向对象编程的核心魅力）

最新推荐文章于 2025-08-14 22:07:01 发布

原创最新推荐文章于 2025-08-14 22:07:01 发布 · 841 阅读

11 ·

CC 4.0 BY-SA版权

文章标签：

#c++

c++ 专栏收录该内容

20 篇文章

订阅专栏

本节目标：

1.多态的概念

2.多态的定义及实现

3.抽象类

4.多态的原理

5.单继承和多继承关系中的虚函数表

6.继承和多态常见的面试问题

引入：

比如买票这个行为，当普通人买票时，是全价票，学生买票时，是半票，军人买票时，优先买

发现三类人同样是买票，却呈现出三种不同的状态

在比如，支付宝的扫红包支付给奖励，有些人几块，有些人几毛

其实这些背后都是一个多态的行为

多态的概念

多态（Polymorphism）是面向对象编程（OOP）的核心概念之一，它允许不同类的对象通过相同的接口进行调用，从而实现 “一个接口，多种实现” 的效果。多态性使得代码更加灵活、可扩展，提高了软件的复用性和可维护性。

多态多态就是多种形态，具体点就是去完成某个行为，不同的对象去完成是会产生不同的状态

多态的定义及实现

多态是在不同继承关系的类的对象，去调同一函数，产生不同的行为。

比如student继承了person，person对象买票全价，student对象买票半价

那么在继承中要构成多态的两个条件：

1.必须通过基类的指针或者引用调用虚函数

2.被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

首先了解什么是虚函数？？？

虚函数：即被virtual修饰的类成员函数称为虚函数（这里不要混淆虚继承，这两没关系，就是用了同一个关键字罢了）

class person
{
 public:
 virtual void buyticket()
 { 
  cout<<"买票-全价"<<endl;
 }
};

虚函数的重写：虚函数的重写也叫覆盖，两者概念一样

派生类中有一个跟基类完全相同的虚函数（即派生类虚函数与基类虚函数的返回值类型，函数名字，参数列表，常量性完全相同），称子类的虚函数重写了基类的虚函数。

class person
{
 public:
 virtual void buyticket()
 { 
  cout<<"买票-全价"<<endl;
 }
};
class student:public person
{
 public:
 virtual void buyticket()
 { 
  cout<<"买票-半价"<<endl;
 }
};

注意：在重写虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写（因为继承后基类的虚函数被继承下来了，在派生类依旧保持虚函数属性），但是这种写法不规范，不建议使用

你是否会有个疑问？这不是构成隐藏吗？

回顾隐藏的概念，只要函数名相同就会构成隐藏

重写的概念，函数签名完全相同（返回值，函数名，参数列表，常量性）就会构成重写

首先先判断是否构成重写，如果不构成重写，那就是隐藏

必须通过基类的指针或者引用调用虚函数

void Func(person& p)
{
 p.buyticket();
}

在之前的继承中我们提到向上转型这个概念，向上转型就是派生类的对象可以赋值给基类的引用或者指针

在这里person&p，无论你传子类对象或者是父类的对象都是合法的，如果你传子类对象，那就会去调子类的买票，如果你传父类对象，就会调父类的买票，实际就是看的是你指向的是什么对象

至此，我们已经初步了解了多态以及多态构成的两个条件：

1.必须通过基类的指针或者引用调用虚函数

2.被调用的必须是虚函数且派生类必须要对基类的虚函数完成重写

但虚函数的重写有两个例外

1.协变（基类与派生类虚函数返回值类型不同）

派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

协变的安全性依赖于子类对象可隐式转换为基类对象的特性

如何理解：因为你子类可以赋值给父类的指针或者引用，这就是向上转型，这是安全的，

2.析构函数的重写（基类与派生类析构函数的名字不同）

如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不同，看起来违背了重写的规则，实则不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理称destructor。

c++11 override和final

c++11提供两个关键字检查是否严格完成重写

1.final：修饰虚函数，表示该虚函数不能再被重写

如果子类重写就会报错

而且这个final还是修饰类，表示这个类是最终形态，那别的类就不能继承

2.override：检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

有时候函数名错一个字母，编译器可能检查不出来，或者一些小型的错误编译器检查不出来

会导致重写出现问题，甚至有时候会误判成隐藏

所以为了避免这种情况，引入override严格检查函数签名

class Base {
public:
    virtual void func(int x) { /* ... */ }  // 基类虚函数
};

class Derived : public Base {
public:
    void func(double x) { /* ... */ }  // 错误：参数类型不同，隐藏而非重写
};

Base* ptr = new Derived();
ptr->func(10);  // 调用Base::func(int)，而非Derived::func

override的具体作用

强制编译器检查重写
确保子类函数确实重写了基类虚函数，而非意外隐藏。
提高代码可读性
明确告诉读者 “这个函数是重写基类的虚函数”。
避免细微错误
例如：
- 参数类型不一致（如int vs double）
- 常量性不一致（如void f() const vs void f()）
- 返回类型不协变

三个概念对比：

抽象类

概念：在虚函数的后面写上=0，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须完成重写，另外纯虚函数更体现了接口继承

接口继承和实现继承区别

接口继承和实现继承是两种不同的继承方式，它们的核心区别在于子类继承的是 “方法的声明” 还是 “方法的实现”。

接口继承：派生类继承基类的方法的声明，通俗来讲就是函数头，所以你必须实现自己的函数体

作用：强调子类遵循统一的接口规范，实现多态，在c++中通过纯虚函数实现

class Shape {
public:
    virtual double area() const = 0;  // 纯虚函数，定义接口但无实现
};

class Circle : public Shape {
public:
    double area() const override {  // 必须实现接口
        return 3.14 * radius * radius;
    }
private:
    double radius;
};

实现继承：派生类继承基类的方法的实现，可选择直接用或者重写

作用：复用基类代码，减少重复实现，在c++中通过普通虚函数或非虚函数实现

class Shape {
public:
    virtual void draw() const {  // 虚函数，提供默认实现
        std::cout << "Drawing a generic shape." << std::endl;
    }
};

class Circle : public Shape {
    // 未重写draw()，直接继承基类实现
};

class Square : public Shape {
public:
    void draw() const override {  // 可选：重写实现
        std::cout << "Drawing a square." << std::endl;
    }
};

总结：纯虚函数的出现就是接口继承，是一种强制多态，如果你没有完成重写，那就无法实例化，更别谈多态，主要目的是定义统一接口，强制规范，强制多态

普通虚函数是实现继承，你可以重写或者不重写都可以完成多态，主要是为了完成复用和扩展

class Base {
public:
    virtual void func() = 0;  // 纯虚函数声明（必须在类外定义实现）
};

// 类外定义纯虚函数的实现
void Base::func() {
    std::cout << "Base::func() implementation." << std::endl;
}

class Derived : public Base {
public:
    void func() override {  // 派生类必须重写
        Base::func();  // 可选：显式调用基类实现
        std::cout << "Derived::func() implementation." << std::endl;
    }
};

注意：

基类的纯虚函数可以有函数实现，但必须在类外定义，但只能通过Base::func()显示调用

不过，这种用法需谨慎，避免违背接口继承的纯粹性。若默认行为对所有派生类都适用，更推荐使用普通虚函数。

多态的原理

对于这个基类，我们实例化了一个对象，发现除了正常存储int _b这个内置类型四个字节外

还多存储了一个 __vfptr放在对象的前面（放在对象的前面还是后面这跟平台有关）

__vfptr：v代表virtual，f代表function，ptr是指针，所以这个我们称之为虚函数表指针，一个含有虚函数的类中至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表，虚函数表是一个静态数组，存储了类的虚函数地址。

含有虚函数的类 -->__vfptr --> 虚表 -->静态数组，虚函数地址

对此，我们给base添加了fun2，然后写一个派生类去继承，并且重写fun1，不重写fun2

根据前面所讲的，含有虚函数的就会有一个虚函数表指针，我们看B，这跟前面讲的一样，含有虚函数表指针，虚函数表指针指向虚表，虚表是一个函数指针数组，里面含有fun1和fun2的函数地址

在看D，D继承_b和自己的成员变量_d这每毛病，注意观察它的虚表，虚表中有一个Derive::fun1

和一个Base::fun2，这是为什么？？？

第一步：先将基类中的虚表内容拷贝一份到派生类虚表

第二步：如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数

第三步：派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后

对这三步理解完，就明白为什么了，就是因为我们先拷贝，拷贝完了之后检查是否进行了重写，因为fun1重写了，所以变成Derive::fun1，后面因为fun2没有重写，用的和基类的就一样

注意：虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的都是存在代码段，只是它的指针又存到了虚表中，另外对象中存的不是虚表，存的是虚表指针

观察虚函数表指针指向的数组有三个元素，我们只写了两个虚函数，为什么有三个，因为最后一个是nullptr用来标记结束的

总结：所有的继承中，我们都会把父类的所有东西都继承下来，所有的函数都会继承后放到派生类的代码段，虚函数表指针指向的虚表也会继承下来

也就是你有两部分存在基类的函数，全部函数无论是虚函数还是非虚函数都在代码段，虚函数表指针中的虚函数表又有一份虚函数地址，所以找到基类的虚函数有两个地方，虚表主要是为了实现多态而存在的，即使你完成了重写，也就是覆盖掉，它在代码段也会有基类的函数，所以也可以通过base::fun找到

结合实例再次分析多态的原理

根据之前的例子我们再次分析

多态的两个条件：

1.虚函数

2.通过基类的指针或者引用调用

这里已经满足两个条件，所以构成多态

对于Mike，因为你是Person类，所以people实际指向的是person类的对象，通过mike的虚表中找到虚函数是Person::BuyTicket()；
对于Johnson，因为你是Student类，所以people实际指向的是Student类的对象，通过Johson的虚表找到虚函数是Student::BuyTicket()；

这样就实现出了不同对象去完成同一行为时，展现出不同的形态再次

深度思考，为什么多态构成要满足这两个条件

编译器的处理流程

当遇到 ptr->func() 这样的调用时，编译器会按以下步骤判断是否触发多态：

检查 ptr 的类型：
- 若 ptr 是基类指针 / 引用（如 Base*），进入下一步。
- 若 ptr 是对象名（如 Derived obj; obj.func()）或派生类指针 / 引用，则直接静态绑定（不触发多态）。
检查 func() 是否为虚函数：
- 若 func() 在基类中被声明为 virtual，则生成动态绑定代码（通过虚表指针查找函数地址）。
- 若 func() 不是虚函数，则静态绑定（直接调用基类版本，无论实际对象类型如何）。

为什么需要这两个条件？

基类指针 / 引用的必要性：
- 只有通过基类类型的指针 / 引用，才能实现 "同一接口调用不同对象" 的多态特性。若直接使用对象名或派生类指针，编译器可直接确定对象类型，无需动态绑定。
- 因为你每个子类肯定都是有基类的同一接口
- 基类指针 / 引用的关键作用是在编译期隐藏对象的具体类型，仅保留基类接口的可见性。
- 也就是如果你用某一个子类，那其他子类如何调用，这都不符合前面所讲的向上转型，只有你使用基类，且符合向上转型，即使你是不同的派生类你都可以调用
虚函数的必要性：
- 普通函数调用在编译期静态绑定，而虚函数通过虚表机制将绑定延迟到运行时，允许根据对象实际类型选择函数实现。