引言在上一篇文章中我们介绍了虚函数的基本概念和规则。今天我们将深入到底层探究运行时多态的实现原理——虚函数表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; // 8vptr cout sizeof(Derived): sizeof(Derived) endl; // 8vptr // 通过指针调用体现动态联编 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; // 1664位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; }面试题7final 关键字对多态的影响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: vectorShape* 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动态联编条件通过指针或引用调用函数是虚函数指针/引用指向派生类对象虚析构函数基类析构函数必须是虚函数否则内存泄漏抽象类至少有一个纯虚函数不能实例化三、面试题总结考点关键点构造/析构中的虚函数不会动态联编调用当前类版本切片问题值传递会丢失派生类信息多重继承多个vptrfinal关键字禁止重写或禁止继承纯虚函数可以有实现很少用但语法允许运行时多态是C面向对象编程的核心特性之一。理解虚函数表vtable和虚函数指针vptr的底层原理能够帮助你理解多态的开销虚函数调用有额外的间接寻址开销避免常见陷阱构造/析构函数中调用虚函数、切片问题正确设计接口纯虚函数作为接口、虚析构函数防止内存泄漏