引言
在上一篇文章中，我们介绍了虚函数的基本概念和规则。今天，我们将深入到底层，探究运行时多态的实现原理------虚函数表（vtable） 和虚函数指针（vptr），以及与之密切相关的静态联编与动态联编。
理解这些底层机制，不仅能帮你写出更高效的多态代码，更是面试中经常考察的重点。
第一部分：静态联编与动态联编
一、什么是联编？
联编（Binding）是指计算机程序自身彼此关联的过程，也就是将函数调用与函数实现代码连接在一起的过程。根据发生时机，分为静态联编和动态联编。
cpp
#include <iostream>
using namespace std;
// 静态联编示例：函数重载
void print(int x) { cout << "int: " << x << endl; }
void print(double x) { cout << "double: " << x << endl; }
// 动态联编示例：虚函数
class Animal {
public:
virtual void speak() { cout << "动物叫" << endl; }
};
class Dog : public Animal {
public:
void speak() override { cout << "汪汪" << endl; }
};
int main() {
// 静态联编：编译时就能确定调用哪个函数
print(10); // 编译时确定调用 print(int)
print(3.14); // 编译时确定调用 print(double)
// 动态联编：运行时才能确定调用哪个函数
Animal* p = new Dog();
p->speak(); // 运行时确定调用 Dog::speak()
delete p;
return 0;
}二、静态联编 vs 动态联编
| 特性 | 静态联编 | 动态联编 |
|---|---|---|
| 发生时机 | 编译阶段 | 运行阶段 |
| 别名 | 早期联编、静态多态 | 晚期联编、动态多态 |
| 实现方式 | 函数重载、模板 | 虚函数、继承 |
| 执行效率 | 高（直接调用） | 低（通过虚表间接调用） |
| 灵活性 | 低 | 高 |
| 判断依据 | 指针/引用的静态类型 | 指针/引用指向的实际对象类型 |
cpp
class Base {
public:
void normal() { cout << "Base::normal" << endl; }
virtual void dynamic() { cout << "Base::dynamic" << endl; }
};
class Derived : public Base {
public:
void normal() { cout << "Derived::normal" << endl; }
void dynamic() override { cout << "Derived::dynamic" << endl; }
};
int main() {
Derived d;
Base* p = &d;
p->normal(); // 静态联编：输出 Base::normal
p->dynamic(); // 动态联编：输出 Derived::dynamic
return 0;
}第二部分：运行时多态的底层原理
一、虚函数表（vtable）和虚函数指针（vptr）
当类中声明了虚函数时，编译器会为该类生成一个虚函数表（vtable） ，并在每个对象中添加一个虚函数指针（vptr） ，指向该类的虚函数表。
二、代码验证
cpp
#include <iostream>
using namespace std;
class Base {
public:
virtual void func1() { cout << "Base::func1" << endl; }
virtual void func2() { cout << "Base::func2" << endl; }
void normal() { cout << "Base::normal" << endl; }
};
class Derived : public Base {
public:
void func1() override { cout << "Derived::func1" << endl; }
virtual void func3() { cout << "Derived::func3" << endl; }
};
int main() {
Base b;
Derived d;
// 查看对象大小（虚函数指针占用8字节（64位）或4字节（32位））
cout << "sizeof(Base): " << sizeof(Base) << endl; // 8（vptr）
cout << "sizeof(Derived): " << sizeof(Derived) << endl; // 8（vptr）
// 通过指针调用，体现动态联编
Base* p = &d;
p->func1(); // 输出 Derived::func1
p->func2(); // 输出 Base::func2
return 0;
}三、动态联编的完整执行流程
cpp
class Grand {
public:
virtual void speak() { cout << "Grand" << endl; }
};
class Parent : public Grand {
public:
void speak() override { cout << "Parent" << endl; }
};
class Child : public Parent {
public:
void speak() override { cout << "Child" << endl; }
};
int main() {
Child c;
Grand* p1 = &c;
Parent* p2 = &c;
p1->speak(); // 输出 Child
p2->speak(); // 输出 Child
// 执行流程：
// 1. 通过指针 p1 找到对象 c
// 2. 从对象 c 中读取 vptr
// 3. 通过 vptr 找到 Child 类的 vtable
// 4. 从 vtable 中找到 speak() 的地址
// 5. 调用 Child::speak()
return 0;
}第三部分：虚析构函数
一、为什么需要虚析构函数？
当通过基类指针删除派生类对象时，如果析构函数不是虚函数，只会调用基类的析构函数，导致派生类的资源未被释放，造成内存泄漏。
cpp
#include <iostream>
#include <cstring>
using namespace std;
// 错误示例：析构函数非虚
class BaseWrong {
public:
~BaseWrong() { cout << "BaseWrong 析构" << endl; }
};
class DerivedWrong : public BaseWrong {
private:
char* buffer;
public:
DerivedWrong() {
buffer = new char[100];
cout << "DerivedWrong 分配内存" << endl;
}
~DerivedWrong() {
delete[] buffer;
cout << "DerivedWrong 释放内存" << endl;
}
};
// 正确示例：析构函数为虚
class BaseCorrect {
public:
virtual ~BaseCorrect() { cout << "BaseCorrect 析构" << endl; }
};
class DerivedCorrect : public BaseCorrect {
private:
char* buffer;
public:
DerivedCorrect() {
buffer = new char[100];
cout << "DerivedCorrect 分配内存" << endl;
}
~DerivedCorrect() override {
delete[] buffer;
cout << "DerivedCorrect 释放内存" << endl;
}
};
int main() {
cout << "=== 错误示例：内存泄漏 ===" << endl;
BaseWrong* p1 = new DerivedWrong();
delete p1; // 只调用 BaseWrong 析构，DerivedWrong 的 buffer 泄漏！
cout << "\n=== 正确示例：正确释放 ===" << endl;
BaseCorrect* p2 = new DerivedCorrect();
delete p2; // 先调用 DerivedCorrect 析构，再调用 BaseCorrect 析构
return 0;
}二、虚析构函数的规则
cpp
class Base {
public:
// 规则1：只要类会被继承，析构函数就应该声明为虚函数
virtual ~Base() = default;
// 规则2：纯虚析构函数（需要提供函数体）
// virtual ~Base() = 0;
};
// Base::~Base() {} // 纯虚析构函数必须在类外提供实现
class Derived : public Base {
public:
~Derived() override = default;
};
// 规则3：基类析构函数为虚，派生类析构函数自动成为虚函数（即使不加override）第四部分：纯虚函数与抽象类
一、纯虚函数的定义
纯虚函数是在基类中声明但没有实现的虚函数，语法是在函数声明后加 = 0。含有纯虚函数的类称为抽象类，不能实例化对象。
cpp
#include <iostream>
using namespace std;
// 抽象类：形状
class Shape {
public:
// 纯虚函数
virtual double getArea() const = 0;
virtual double getPerimeter() const = 0;
virtual void draw() const = 0;
// 抽象类可以有普通成员函数
void info() const {
cout << "这是一个形状" << endl;
}
// 抽象类可以有成员变量
string color;
// 抽象类可以有构造函数和析构函数
Shape() : color("red") {}
virtual ~Shape() {}
};
// 具体类：圆形
class Circle : public Shape {
private:
double radius;
public:
Circle(double r) : radius(r) {}
double getArea() const override {
return 3.14159 * radius * radius;
}
double getPerimeter() const override {
return 2 * 3.14159 * radius;
}
void draw() const override {
cout << "绘制一个半径为 " << radius << " 的圆" << endl;
}
};
// 具体类：矩形
class Rectangle : public Shape {
private:
double width, height;
public:
Rectangle(double w, double h) : width(w), height(h) {}
double getArea() const override {
return width * height;
}
double getPerimeter() const override {
return 2 * (width + height);
}
void draw() const override {
cout << "绘制一个 " << width << "x" << height << " 的矩形" << endl;
}
};
int main() {
// Shape s; // 错误！不能实例化抽象类
Circle c(5);
Rectangle r(4, 6);
Shape* shapes[] = {&c, &r};
for (Shape* s : shapes) {
s->draw();
cout << "面积: " << s->getArea() << endl;
cout << "周长: " << s->getPerimeter() << endl;
cout << "颜色: " << s->color << endl;
}
return 0;
}二、抽象类的特点
cpp
// 1. 抽象类不能实例化对象
// Shape s; // 错误
// 2. 抽象类可以定义指针和引用
Shape* p; // 正确
Shape& r = c; // 正确
// 3. 派生类必须实现所有纯虚函数，否则仍是抽象类
class Triangle : public Shape {
// 没有实现 getArea() 等，Triangle 仍是抽象类
};
// 4. 抽象类可以有构造函数和析构函数
// 5. 抽象类可以有成员变量和普通成员函数
// 6. 抽象类可以作为接口使用三、纯虚析构函数
纯虚析构函数比较特殊：它需要被声明为纯虚，但必须提供函数体。
cpp
class Interface {
public:
virtual ~Interface() = 0; // 纯虚析构函数声明
};
// 必须提供实现
Interface::~Interface() {
cout << "Interface 析构" << endl;
}
class Impl : public Interface {
public:
~Impl() override {
cout << "Impl 析构" << endl;
}
};
int main() {
Interface* p = new Impl();
delete p; // 先调用 Impl 析构，再调用 Interface 析构
return 0;
}第五部分：联编相关面试题
面试题1：静态联编与动态联编的判断
cpp
class A {
public:
virtual void f() { cout << "A::f" << endl; }
void g() { cout << "A::g" << endl; }
};
class B : public A {
public:
void f() override { cout << "B::f" << endl; }
void g() { cout << "B::g" << endl; }
};
int main() {
B b;
A* p = &b;
p->f(); // 动态联编 → B::f
p->g(); // 静态联编 → A::g
return 0;
}面试题2：构造函数和析构函数中的虚函数
cpp
class Base {
public:
Base() { func(); }
virtual void func() { cout << "Base::func" << endl; }
~Base() { func(); }
};
class Derived : public Base {
public:
virtual void func() override { cout << "Derived::func" << endl; }
};
int main() {
Derived d;
// 输出：
// Base::func （构造时，Derived 部分还未构造，虚表指向 Base）
// Base::func （析构时，Derived 部分已析构，虚表已恢复为 Base）
return 0;
}重要结论： 构造函数和析构函数中调用虚函数，不会发生动态联编，而是调用当前类自己的版本。
面试题3：虚函数表的存在位置
cpp
class NoVirtual {
int x;
public:
void func() {}
};
class HasVirtual {
int x;
public:
virtual void func() {}
};
int main() {
cout << "sizeof(NoVirtual): " << sizeof(NoVirtual) << endl; // 4
cout << "sizeof(HasVirtual): " << sizeof(HasVirtual) << endl; // 16（64位：vptr 8 + int 4 + 对齐4）
return 0;
}面试题4：多重继承的虚函数表
cpp
class Base1 {
public:
virtual void f1() { cout << "Base1::f1" << endl; }
};
class Base2 {
public:
virtual void f2() { cout << "Base2::f2" << endl; }
};
class Derived : public Base1, public Base2 {
public:
void f1() override { cout << "Derived::f1" << endl; }
void f2() override { cout << "Derived::f2" << endl; }
};
int main() {
Derived d;
Base1* p1 = &d;
Base2* p2 = &d;
p1->f1(); // Derived::f1
p2->f2(); // Derived::f2
// 多重继承的对象有多个 vptr
cout << "sizeof(Derived): " << sizeof(Derived) << endl; // 16（两个 vptr）
return 0;
}面试题5：切片问题与多态
cpp
class Base {
public:
virtual void show() { cout << "Base" << endl; }
};
class Derived : public Base {
public:
void show() override { cout << "Derived" << endl; }
};
void printByValue(Base b) {
b.show(); // 切片发生，总是输出 Base
}
void printByPointer(Base* b) {
b->show(); // 多态，输出实际类型
}
int main() {
Derived d;
printByValue(d); // 输出 Base（切片）
printByPointer(&d); // 输出 Derived
// 切片：将派生类对象赋值给基类对象时，派生类部分被切掉
Base b = d;
b.show(); // Base
return 0;
}面试题6：纯虚函数可以有实现
cpp
class Base {
public:
virtual void func() = 0;
};
// 纯虚函数可以有实现（但很少这样用）
void Base::func() {
cout << "Base::func 默认实现" << endl;
}
class Derived : public Base {
public:
void func() override {
Base::func(); // 调用基类的实现
cout << "Derived::func" << endl;
}
};
int main() {
Derived d;
d.func();
// 输出：
// Base::func 默认实现
// Derived::func
return 0;
}面试题7：final 关键字对多态的影响
cpp
class Base {
public:
virtual void func1() { cout << "Base::func1" << endl; }
virtual void func2() final { cout << "Base::func2" << endl; } // final：禁止重写
};
class Derived : public Base {
public:
void func1() override { cout << "Derived::func1" << endl; }
// void func2() override { } // 错误！func2 被 final 禁止重写
};
class Final final : public Base { // final：禁止继承
};
// class Test : public Final { }; // 错误！Final 不能被继承
int main() {
Derived d;
Base* p = &d;
p->func1(); // Derived::func1（多态仍然有效）
p->func2(); // Base::func2（无法重写）
return 0;
}第六部分：完整示例------图形系统
cpp
#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
// 抽象基类
class Shape {
protected:
string color;
public:
Shape(const string& c = "red") : color(c) {}
// 纯虚函数
virtual double getArea() const = 0;
virtual double getPerimeter() const = 0;
virtual void draw() const = 0;
// 普通成员函数
string getColor() const { return color; }
void setColor(const string& c) { color = c; }
// 虚析构函数（重要！）
virtual ~Shape() {
cout << "Shape 析构" << endl;
}
};
// 圆形
class Circle : public Shape {
private:
double radius;
public:
Circle(double r, const string& c = "red") : Shape(c), radius(r) {}
double getArea() const override {
return M_PI * radius * radius;
}
double getPerimeter() const override {
return 2 * M_PI * radius;
}
void draw() const override {
cout << "画一个 " << color << " 的圆，半径=" << radius << endl;
}
~Circle() {
cout << "Circle 析构" << endl;
}
};
// 矩形
class Rectangle : public Shape {
private:
double width, height;
public:
Rectangle(double w, double h, const string& c = "red")
: Shape(c), width(w), height(h) {}
double getArea() const override {
return width * height;
}
double getPerimeter() const override {
return 2 * (width + height);
}
void draw() const override {
cout << "画一个 " << color << " 的矩形，"
<< width << "x" << height << endl;
}
~Rectangle() {
cout << "Rectangle 析构" << endl;
}
};
// 三角形
class Triangle : public Shape {
private:
double a, b, c;
public:
Triangle(double a, double b, double c, const string& col = "red")
: Shape(col), a(a), b(b), c(c) {}
double getArea() const override {
double s = (a + b + c) / 2;
return sqrt(s * (s - a) * (s - b) * (s - c));
}
double getPerimeter() const override {
return a + b + c;
}
void draw() const override {
cout << "画一个 " << color << " 的三角形，边长="
<< a << "," << b << "," << c << endl;
}
~Triangle() {
cout << "Triangle 析构" << endl;
}
};
// 图形管理器
class ShapeManager {
private:
vector<Shape*> shapes;
public:
void add(Shape* s) {
shapes.push_back(s);
}
void drawAll() const {
for (Shape* s : shapes) {
s->draw();
}
}
double getTotalArea() const {
double total = 0;
for (Shape* s : shapes) {
total += s->getArea();
}
return total;
}
~ShapeManager() {
for (Shape* s : shapes) {
delete s; // 虚析构函数确保正确释放
}
}
};
int main() {
ShapeManager manager;
manager.add(new Circle(5, "blue"));
manager.add(new Rectangle(4, 6, "green"));
manager.add(new Triangle(3, 4, 5, "yellow"));
cout << "=== 绘制所有图形 ===" << endl;
manager.drawAll();
cout << "\n=== 总面积 ===" << endl;
cout << "总面积: " << manager.getTotalArea() << endl;
// 多态数组
cout << "\n=== 多态演示 ===" << endl;
Shape* shapes[] = {
new Circle(3),
new Rectangle(2, 3),
new Triangle(6, 8, 10)
};
for (Shape* s : shapes) {
cout << "面积: " << s->getArea() << ", ";
s->draw();
}
for (Shape* s : shapes) {
delete s;
}
return 0;
}总结
一、核心概念对比
| 概念 | 静态联编 | 动态联编 |
|---|---|---|
| 发生时机 | 编译时 | 运行时 |
| 实现方式 | 函数重载、模板 | 虚函数、继承 |
| 效率 | 高 | 稍低 |
| 灵活性 | 低 | 高 |
| 概念 | 虚函数 | 纯虚函数 |
|---|---|---|
| 声明 | virtual void func() |
virtual void func() = 0 |
| 是否有实现 | 必须有 | 可选（通常没有） |
| 类是否可实例化 | 可以 | 不可以（抽象类） |
| 派生类要求 | 可选重写 | 必须重写（否则仍是抽象类） |
二、运行时多态要点
-
虚函数表（vtable）：每个有虚函数的类都有一个虚函数表
-
虚函数指针（vptr）：每个对象都有一个vptr指向所属类的vtable
-
动态联编条件：
-
通过指针或引用调用
-
函数是虚函数
-
指针/引用指向派生类对象
-
-
虚析构函数：基类析构函数必须是虚函数，否则内存泄漏
-
抽象类：至少有一个纯虚函数，不能实例化
三、面试题总结
| 考点 | 关键点 |
|---|---|
| 构造/析构中的虚函数 | 不会动态联编，调用当前类版本 |
| 切片问题 | 值传递会丢失派生类信息 |
| 多重继承 | 多个vptr |
| final关键字 | 禁止重写或禁止继承 |
| 纯虚函数可以有实现 | 很少用，但语法允许 |
运行时多态是C++面向对象编程的核心特性之一。理解虚函数表（vtable）和虚函数指针（vptr）的底层原理，能够帮助你：
-
理解多态的开销：虚函数调用有额外的间接寻址开销
-
避免常见陷阱：构造/析构函数中调用虚函数、切片问题
-
正确设计接口：纯虚函数作为接口、虚析构函数防止内存泄漏