多态的概念#

定义#

多态(polymorphism)：即”多种形态”，指同一接口表现出不同行为的能力。

多态的分类#

编译时多态（静态多态）
- 函数重载
- 函数模板
- 特点：编译时确定调用哪个函数，通过参数类型匹配
运行时多态（动态多态）
- 通过虚函数实现
- 特点：运行时根据对象类型确定调用哪个函数

实际应用示例#

1
// 买票场景
2
普通人买票 → 全价
3
学生买票 → 优惠价（5折或75折）
4
军人买票 → 优先购票
5

6
// 动物叫场景
7
猫对象 → "喵"
8
狗对象 → "汪汪"

多态的定义与实现#

多态的构成条件（三个必要条件）#

继承关系：存在继承关系的类
虚函数重写：派生类重写基类的虚函数
基类指针/引用：通过基类的指针或引用调用虚函数

虚函数 (Virtual Function)#

1
class Person {
2
public:
3
    // 虚函数声明
4
    virtual void BuyTicket() {
5
        cout << "买票-全价" << endl;
6
    }
7
};

虚函数重写/覆盖 (Override)#

派生类中定义与基类完全相同的虚函数
“完全相同”指：函数名、参数列表、返回值类型都相同

1
class Student : public Person {
2
public:
3
    // 重写基类虚函数
4
    virtual void BuyTicket() {
5
        cout << "买票-打折" << endl;
6
    }
7
};

多态调用示例#

1
void Func(Person* ptr) {
2
    ptr->BuyTicket();  // 多态调用：根据ptr指向的实际对象类型决定
3
}
4

5
int main() {
6
    Person ps;
7
    Student st;
8

9
    Func(&ps);  // 输出：买票-全价
10
    Func(&st);  // 输出：买票-打折
11

12
    return 0;
13
}

虚函数重写的特殊情况#

协变#

允许派生类虚函数返回类型与基类不同
要求：返回类型是基类/派生类关系的指针或引用

1
class A {};
2
class B : public A {};
3

4
class Person {
5
public:
6
    virtual A* BuyTicket() {
7
        cout << "买票-全价" << endl;
8
        return nullptr;
9
    }
10
};
11

12
class Student : public Person {
13
public:
14
    virtual B* BuyTicket() {  // 协变：返回派生类指针
15
        cout << "买票-打折" << endl;
16
        return nullptr;
17
    }
18
};

析构函数的重写#

基类析构函数为虚函数时，派生类析构函数自动构成重写
编译器将析构函数名统一处理为destructor
为什么基类析构函数要声明为虚函数：当通过基类指针删除派生类对象时，如果基类没有虚析构函数，那么只会调用基类的析构函数，导致派生类的资源泄漏。

1
class A {
2
public:
3
    virtual ~A() {  // 虚析构函数
4
        cout << "~A()" << endl;
5
    }
6
};
7

8
class B : public A {
9
public:
10
    ~B() {  // 自动构成重写
11
        cout << "~B()" << endl;
12
        delete _p;
13
    }
14
private:
15
    int* _p = new int[10];
16
};
17

18
int main() {
19
    A* p = new B;
20
    delete p;  // 正确调用：~B() → ~A()
21
    return 0;
22
}

派生类virtual关键字可省略#

1
class Student : public Person {
2
public:
3
    void BuyTicket() {  // 不加virtual也构成重写（不推荐）
4
        cout << "买票-打折" << endl;
5
    }
6
};

访问权限不影响重写#

1
class Person {
2
private:
3
    virtual void BuyTicket() {  // private虚函数
4
        cout << "买票-全价" << endl;
5
    }
6
public:
7
    void Func() {
8
        BuyTicket();
9
    }
10
};
11

12
class Student : public Person {
13
public:
14
    virtual void BuyTicket() {  // 可以重写private虚函数
15
        cout << "买票-打折" << endl;
16
    }
17
};

选择题示例#

1
class A {
2
public:
3
    virtual void func(int val = 1) {
4
        std::cout << "A->" << val << std::endl;
5
    }
6
    virtual void test() { func(); }
7
};
8

9
class B : public A {
10
public:
11
    void func(int val = 0) {
12
        std::cout << "B->" << val << std::endl;
13
    }
14
};
15

16
int main() {
17
    B* p = new B;
18
    p->test();  // 输出：B->1
19
    return 0;
20
}

谁调用了 test()？
- p 是 B 的指针
- 但 test() 是 A 的函数（B继承来的）
- 效果相当于：A 在调用 test()
test() 里面做了什么？

1
void test() { func(); }  // 在A的眼里，这是 func(1)

重写的本质是重写虚函数的实现，故函数参数该使用基函数参数1
在 A 的代码里，func() 默认参数是 1

到底执行哪个 func()？
- 虽然参数是 A 决定的（1）
- 但 func() 是虚函数，实际执行 B 的版本
- 所以最终：B 的 func(1)
输出：B->1

override关键字#

显式声明重写，增强代码可读性
编译器检查是否真正重写

1
class Car {
2
public:
3
    virtual void Drive() {}
4
};
5

6
class Benz : public Car {
7
public:
8
    virtual void Drive() override {  // 明确表示重写
9
        cout << "Benz-舒适" << endl;
10
    }
11

12
    // 错误示例：函数名拼写错误
13
    virtual void Dirve() override {  // 编译错误：没有重写任何函数
14
        cout << "Benz-舒适" << endl;
15
    }
16
};

final关键字#

修饰虚函数：禁止进一步重写
修饰类：禁止继承

1
// 1. 禁止重写虚函数
2
class Car {
3
public:
4
    virtual void Drive() final {}  // 禁止派生类重写
5
};
6

7
class Benz : public Car {
8
public:
9
    virtual void Drive() {  // 编译错误：final函数不能被重写
10
        cout << "Benz-舒适" << endl;
11
    }
12
};
13

14
// 2. 禁止继承类
15
class Car final {  // Car类不能被继承
16
public:
17
    virtual void Drive() {}
18
};
19

20
class Benz : public Car {  // 编译错误：不能继承final类
21
};

重载，重载，隐藏对比#

特性	作用域	函数名	参数列表	返回值	virtual关键字	其他
重载(Overload)	同一类/同一作用域	相同	必须不同	可不同	无关	编译时确定
重写/覆盖(Override)	基类和派生类	相同	必须相同	必须相同（协变除外）	必须是虚函数	运行时多态
隐藏(Hiding)	基类和派生类	相同	可同可不同	可同可不同	无关	不构成重写就是隐藏

纯虚函数#

虚函数后面加= 0
可以不提供实现（也可以提供）

1
virtual void Drive() = 0;  // 纯虚函数

抽象类#

包含纯虚函数的类
不能实例化对象
派生类必须重写所有纯虚函数，否则也是抽象类

1
class Car {  // 抽象类
2
public:
3
    virtual void Drive() = 0;  // 纯虚函数
4
    virtual ~Car() {}          // 虚析构函数
5
};
6

7
class Benz : public Car {
8
public:
9
    virtual void Drive() override {  // 必须重写
10
        cout << "Benz-舒适" << endl;
11
    }
12
};
13

14
int main() {
15
    // Car car;  // 错误：抽象类不能实例化
16
    Car* p = new Benz;  // 正确：通过指针/引用
17
    p->Drive();
18
    delete p;
19
    return 0;
20
}

多态的原理（底层实现）#

虚函数表指针(vptr)#

1
class Base {
2
public:
3
    virtual void Func1() { cout << "Func1()" << endl; }
4
private:
5
    int _b = 1;
6
    char _ch = 'x';
7
};
8

9
int main() {
10
    Base b;
11
    cout << sizeof(b) << endl;  // 32位: 12 bytes (vptr:4 + int:4 + char:1 + padding:3)
12
    return 0;
13
}

对象内存布局#

1
[ vptr(4) | _b(4) | _ch(1) | padding(3) ]

虚函数表(vtable)结构#

1
class Base {
2
public:
3
    virtual void func1() { cout << "Base::func1" << endl; }
4
    virtual void func2() { cout << "Base::func2" << endl; }
5
    void func3() { cout << "Base::func3" << endl; }  // 普通函数
6
    int a = 1;
7
};
8

9
class Derive : public Base {
10
public:
11
    virtual void func1() override { cout << "Derive::func1" << endl; }  // 重写
12
    virtual void func4() { cout << "Derive::func4" << endl; }           // 新增虚函数
13
    int b = 2;
14
};

虚函数表内容#

Base对象vtable：[&Base::func1, &Base::func2]
Derive对象vtable：[&Derive::func1, &Base::func2, &Derive::func4]

多态调用过程#

1
Base* ptr = new Derive;
2
ptr->func1();  // 多态调用

调用过程：

通过ptr找到对象
从对象头部获取vptr
通过vptr找到虚函数表
在虚函数表中找到func1的地址（&Derive::func1）
调用该函数

动态绑定 vs 静态绑定#

1
// 1. 动态绑定（多态）
2
ptr->virtual_func();  // 运行时确定函数地址
3

4
// 汇编代码示例：
5
// mov eax, dword ptr [ptr]    ; 获取对象地址
6
// mov edx, dword ptr [eax]    ; 获取vptr
7
// mov eax, dword ptr [edx]    ; 获取虚函数地址
8
// call eax                    ; 调用函数
9

10
// 2. 静态绑定（非多态）
11
ptr->non_virtual_func();  // 编译时确定函数地址
12

13
// 汇编代码示例：
14
// call Base::non_virtual_func ; 直接调用固定地址

虚函数表验证代码#

1
#include <iostream>
2
using namespace std;
3

4
// 打印各种内存区域的地址
5
void PrintMemoryLayout() {
6
    int stack_var = 0;
7
    static int static_var = 0;
8
    int* heap_var = new int(0);
9
    const char* const_var = "constant";
10

11
    cout << "栈区地址: " << &stack_var << endl;
12
    cout << "静态区地址: " << &static_var << endl;
13
    cout << "堆区地址: " << heap_var << endl;
14
    cout << "常量区地址: " << (void*)const_var << endl;
15
}
16

17
// 查看虚函数表地址
18
class Base {
19
public:
20
    virtual void f1() {}
21
    virtual void f2() {}
22
};
23

24
int main() {
25
    PrintMemoryLayout();
26

27
    Base b;
28
    Base* p = &b;
29

30
    // 获取虚函数表地址（对象前4/8字节）
31
    void** vtable = *(void***)p;
32
    cout << "虚函数表地址: " << vtable << endl;
33
    cout << "第一个虚函数地址: " << vtable[0] << endl;
34
    cout << "第二个虚函数地址: " << vtable[1] << endl;
35

36
    // VS编译器会在虚函数表末尾放0x00000000标记
37
    // g++编译器可能不放
38

39
    delete heap_var;
40
    return 0;
41
}

虚函数表知识点#

基类对象的虚函数表中存放基类所有虚函数的地址。同类型的对象共⽤同⼀张虚表，不同类型的对象各⾃有独⽴的虚表，所以基类和派⽣类有各⾃独⽴的虚表。•派⽣类由两部分构成，继承下来的基类和⾃⼰的成员，⼀般情况下，继承下来的基类中有虚函数表指针，⾃⼰就不会再⽣成虚函数表指针。但是要注意的这⾥继承下来的基类部分虚函数表指针和基类对象的虚函数表指针不是同⼀个，就像基类对象的成员和派⽣类对象中的基类对象成员也独⽴的。
派⽣类中重写的基类的虚函数，派⽣类的虚函数表中对应的虚函数就会被覆盖成派⽣类重写的虚函数地址。
派⽣类的虚函数表中包含，(1)基类的虚函数地址，(2)派⽣类重写的虚函数地址完成覆盖，派⽣类⾃⼰的虚函数地址三个部分。
虚函数表本质是⼀个存虚函数指针的指针数组，⼀般情况这个数组最后⾯放了⼀个0x00000000标记。(这个C++并没有进⾏规定，各个编译器⾃⾏定义的，vs系列编译器会再后⾯放个0x00000000标记，g++系列编译不会放)
虚函数存在哪的？虚函数和普通函数⼀样的，编译好后是⼀段指令，都是存在代码段的，只是虚函数的地址⼜存到了虚表中。
虚函数表存在哪的？这个问题严格说并没有标准答案C++标准并没有规定，我们写下⾯的代码可以对⽐验证⼀下。vs下是存在代码段(常量区)

音乐

音乐

多态的概念#

定义#

多态的分类#

实际应用示例#

多态的定义与实现#

多态的构成条件（三个必要条件）#

虚函数 (Virtual Function)#

虚函数重写/覆盖 (Override)#

多态调用示例#

虚函数重写的特殊情况#

协变#

析构函数的重写#

派生类virtual关键字可省略#

访问权限不影响重写#

选择题示例#

override关键字#

final关键字#

重载，重载，隐藏对比#

纯虚函数#

抽象类#

多态的原理（底层实现）#

虚函数表指针(vptr)#

对象内存布局#

虚函数表(vtable)结构#

虚函数表内容#

多态调用过程#

动态绑定 vs 静态绑定#

虚函数表验证代码#

虚函数表知识点#

文章分享