C++运行时多态深度解析：从原理到实践

引言

在上一篇文章中，我们介绍了虚函数的基本概念和规则。今天，我们将深入到底层，探究运行时多态的实现原理——虚函数表（vtable）和虚函数指针（vptr），以及与之密切相关的静态联编与动态联编。

理解这些底层机制，不仅能帮你写出更高效的多态代码，更是面试中经常考察的重点。

第一部分：静态联编与动态联编

一、什么是联编？

联编（Binding）是指计算机程序自身彼此关联的过程，也就是将函数调用与函数实现代码连接在一起的过程。根据发生时机，分为静态联编和动态联编。

#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 动态联编

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），指向该类的虚函数表。

二、代码验证

#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; }

三、动态联编的完整执行流程

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; }

第三部分：虚析构函数

一、为什么需要虚析构函数？

当通过基类指针删除派生类对象时，如果析构函数不是虚函数，只会调用基类的析构函数，导致派生类的资源未被释放，造成内存泄漏。

#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; }

二、虚析构函数的规则

class Base { public: // 规则1：只要类会被继承，析构函数就应该声明为虚函数 virtual ~Base() = default; // 规则2：纯虚析构函数（需要提供函数体） // virtual ~Base() = 0; }; // Base::~Base() {} // 纯虚析构函数必须在类外提供实现 class Derived : public Base { public: ~Derived() override = default; }; // 规则3：基类析构函数为虚，派生类析构函数自动成为虚函数（即使不加override）

第四部分：纯虚函数与抽象类

一、纯虚函数的定义

纯虚函数是在基类中声明但没有实现的虚函数，语法是在函数声明后加= 0。含有纯虚函数的类称为抽象类，不能实例化对象。

#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; }

二、抽象类的特点

// 1. 抽象类不能实例化对象 // Shape s; // 错误 // 2. 抽象类可以定义指针和引用 Shape* p; // 正确 Shape& r = c; // 正确 // 3. 派生类必须实现所有纯虚函数，否则仍是抽象类 class Triangle : public Shape { // 没有实现 getArea() 等，Triangle 仍是抽象类 }; // 4. 抽象类可以有构造函数和析构函数 // 5. 抽象类可以有成员变量和普通成员函数 // 6. 抽象类可以作为接口使用

三、纯虚析构函数

纯虚析构函数比较特殊：它需要被声明为纯虚，但必须提供函数体。

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：静态联编与动态联编的判断

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：构造函数和析构函数中的虚函数

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：虚函数表的存在位置

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：多重继承的虚函数表

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：切片问题与多态

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：纯虚函数可以有实现

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 关键字对多态的影响

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; }

第六部分：完整示例——图形系统

#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; }

总结

一、核心概念对比

二、运行时多态要点

1. 虚函数表（vtable）：每个有虚函数的类都有一个虚函数表

2. 虚函数指针（vptr）：每个对象都有一个vptr指向所属类的vtable

3. 动态联编条件：

   • 通过指针或引用调用

   • 函数是虚函数

   • 指针/引用指向派生类对象

4. 虚析构函数：基类析构函数必须是虚函数，否则内存泄漏

5. 抽象类：至少有一个纯虚函数，不能实例化

三、面试题总结

运行时多态是C++面向对象编程的核心特性之一。理解虚函数表（vtable）和虚函数指针（vptr）的底层原理，能够帮助你：

1. 理解多态的开销：虚函数调用有额外的间接寻址开销

2. 避免常见陷阱：构造/析构函数中调用虚函数、切片问题

3. 正确设计接口：纯虚函数作为接口、虚析构函数防止内存泄漏