C++算法

C++ 抽象类与多态原理：从纯虚函数到虚表机制

C++ 抽象类通过纯虚函数定义接口规范，派生类必须重写才能实例化。多态底层依赖虚表指针和虚函数表实现动态绑定。虚表存储虚函数地址，位于代码段。对象包含虚表指针指向虚表。基类指针调用虚函数时，运行时根据实际对象类型查找虚表确定函数地址。静态绑定在编译时确定，动态绑定在运行时确定。析构函数建议设为虚函数以正确释放资源。

奇形怪状发布于 2026/2/10更新于 2026/10/243.7K 浏览

C++ 抽象类与多态原理：从纯虚函数到虚表机制

前言

在 C++ 多态体系中，纯虚函数与抽象类是实现'接口规范'的核心工具，而虚函数表（vtable）与虚表指针（vfptr）则是多态底层实现的关键。本文将基于实战代码，从纯虚函数与抽象类的定义、使用场景入手，逐步拆解多态的底层原理——包括虚表指针的存在性、虚函数表的结构与存储位置，最终帮你打通'多态怎么用'到'多态如何实现'的认知链路。

一、纯虚函数与抽象类：强制接口规范的'契约'

在实际开发中，我们经常需要定义一个'只规定行为，不提供具体实现'的类。C++ 通过纯虚函数和抽象类实现这种'接口契约'。

1.1 纯虚函数：没有实现的'接口声明'

在虚函数的声明后加=0，该函数即为纯虚函数。纯虚函数无需在基类中实现（语法上允许实现，但无实际意义，因为会被派生类重写），其核心作用是'强制派生类必须重写该函数'。

1.2 抽象类：包含纯虚函数的'不可实例化类'

包含纯虚函数的类称为抽象类，它有两个关键特性：

无法直接实例化对象（编译器会报错）；
派生类若未重写基类的所有纯虚函数，自身也会成为抽象类，同样无法实例化。

有了上面的知识储备，我们来看下代码示例吧：

#include <iostream>
using namespace std;

// 抽象类：包含纯虚函数 Drive()
class Car {
public:
    // 纯虚函数：只声明接口，不提供实现
    virtual void Drive() = 0;
};

// 派生类 Benz：重写纯虚函数，成为'具体类'
class Benz : public Car {
public:
    // 必须重写 Drive()，否则 Benz 也是抽象类
    virtual void Drive() {
        cout << "Benz-舒适" << endl;
    }
};

// 派生类 BMW：重写纯虚函数，成为'具体类'
class BMW : public Car {
public:
       {
        cout <<  << endl;
    }
};

{
    
    
    
    
    Car* pBenz =  Benz;
    pBenz->(); 
    
    Car* pBMW =  BMW;
    pBMW->(); 
    
     pBenz;
     pBMW;
     ;
}

class Base {
public:
    // 虚函数：触发编译器生成虚表指针
    virtual void Func1() { cout << "Func1()" << endl; }
    virtual void Func2() { cout << "Func2()" << endl; }
    // 普通函数
    void Func3() { cout << "Func3()" << endl; }
protected:
    int _b = 1;
    char _ch = 'x';
};

int main() {
    Base b;
    // 除了我们能看到的_b 和_ch，其实有虚函数的类就会有一个虚函数表指针 (32 位下 4 字节，64 位下 8 字节)
    // 因为一个类所有虚函数的地址要被放到这个类对象的虚函数表中，虚函数表也简称虚表。
    cout << sizeof(b) << endl; // 32 位：4+4+1->12
    // 输出结果：32 位环境下为 12 字节，64 位环境下为 16 字节
    return 0;
}

class Person {
public:
    virtual void BuyTicket() {
        cout << "买票 - 全价" << endl;
    }
private:
    string _name;
};

class Student : public Person {
public:
    virtual void BuyTicket() {
        cout << "买票 - 打折" << endl;
    }
private:
    string _id;
};

void Func(Person& ptr) {
    // 这里可以看到虽然都是 Person 指针 Ptr 在调用 BuyTicket
    // 但是跟 ptr 没关系，而是由 ptr 指向的对象决定的。
    ptr.BuyTicket();
}

int main() {
    // 其次多态不仅仅发生在派生类对象之间，多个派生类继承基类，重写虚函数后
    // 多态也会发生在多个派生类之间。
    Person ps;
    Student st;
    Func(ps);
    Func(st);
    
    // 这三个的虚函数表是一样的，同类型的对象共用一虚表
    // Person p1;
    // Person p2;
    // Person p3;
    return 0;
}

class Base {
public:
    virtual void func1() { cout << "Base::func1" << endl; }
    virtual void func2() { cout << "Base::func2" << endl; }
    // 普通函数：不存入虚表
    void func5() { cout << "Base::func5" << endl; }
protected:
    int a = 1;
};

class Derive : public Base {
public:
    // 重写基类的 func1：会覆盖虚表中 func1 的地址
    virtual void func1() { cout << "Derive::func1" << endl; }
    // 派生类新增虚函数：会追加到虚表末尾
    virtual void func3() { cout << "Derive::func1" << endl; }
    // 普通函数：不存入虚表
    void func4() { cout << "Derive::func4" << endl; }
protected:
    int b = 2;
};

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

// 基类指针指向派生类对象
Person* ptr = new Student;
// 动态绑定流程：
// 1. 从 ptr 指向的 Student 对象中，取出 vfptr；
// 2. 通过 vfptr 找到 Student 类的虚表；
// 3. 在虚表中找到 BuyTicket 对应的地址（Student::BuyTicket 的地址）；
// 4. 调用该地址对应的函数，输出'买票 - 打折'。

int main() {
    int i = 0;
    static int j = 1;
    int* p1 = new int;
    const char* p2 = "xxxxxxxx";
    printf("栈:%p\n", &i);
    printf("静态区:%p\n", &j);
    printf("堆:%p\n", p1);
    printf("常量区:%p\n", p2);
    
    Base b;
    Derive d;
    printf("Base 虚函数表地址:%p\n", *((int*)&b));
    printf("Derive 虚函数表地址:%p\n", *((int*)&d));
    printf("虚函数地址:%p\n", &Base::func1);
    printf("普通函数地址:%p\n", &Base::func5);
    return 0;
}

特性	定义	示例
重载	同一类中，方法名相同，参数列表（参数类型、个数、顺序）不同，与返回值类型无关	类中 `add(int a, int b)` 和 `add(double a, double b)`
重写（覆盖）	子类继承父类后，对父类的虚函数进行重新实现，方法名、参数列表、返回值类型（协变情况除外）完全相同	父类 `Animal` 的虚函数 `makeSound()`，子类 `Dog` 重写为 `void makeSound() { cout << "汪汪" << endl; }`
重定义（隐藏）	子类中定义了与父类同名的非虚函数，隐藏父类的该函数	父类有 `func()`，子类也定义 `func()`，子类对象调用 `func()` 时执行子类的，父类对象调用执行父类的

调用场景	普通函数调用机制	虚函数调用机制	性能差异根源
普通对象调用	编译时直接绑定函数地址，直接跳转执行	编译时直接绑定函数地址，直接跳转执行	无差异
基类指针/引用多态调用	编译时直接绑定函数地址，直接跳转执行	运行时通过 vptr 找 vtable，再找函数地址执行	虚函数多了查表的运行时开销

C++ 抽象类与多态原理：从纯虚函数到虚表机制

C++ 抽象类与多态原理：从纯虚函数到虚表机制

前言

一、纯虚函数与抽象类：强制接口规范的'契约'

1.1 纯虚函数：没有实现的'接口声明'

1.2 抽象类：包含纯虚函数的'不可实例化类'

C++ 抽象类与多态原理：从纯虚函数到虚表机制

C++ 抽象类与多态原理：从纯虚函数到虚表机制

前言

一、纯虚函数与抽象类：强制接口规范的'契约'

1.1 纯虚函数：没有实现的'接口声明'

1.2 抽象类：包含纯虚函数的'不可实例化类'

更多推荐文章

相关免费在线工具

二、多态的底层原理：虚表指针与虚函数表

2.1 虚表指针（vfptr）：对象中的'导航器'

2.2 多态的实现原理

2.3 虚函数表（vtable）：存储虚函数地址的'数组'

2.4 动态绑定与静态绑定

三、关键问题辨析与总结

3.1 虚函数存在哪里？虚表又存在哪里？

3.2 实战注意事项：

四、多态考察的一些常见问题 (重点，面试高频题)

结语

更多推荐文章

相关免费在线工具