在C++中，虚函数通过virtual关键字实现运行时多态，使基类指针能根据对象实际类型调用对应函数。1. 使用virtual声明基类函数以开启动态绑定；2. 派生类重写该函数时可使用override关键字确保正确覆盖；3. 虚函数机制依赖vtable（虚函数表）和vptr（虚函数表指针），每个含虚函数的类有vtable存储函数地址，每个对象包含指向vtable的vptr；4. 通过基类指针调用虚函数时，程序通过vptr找到实际类型的vtable并调用相应函数，实现运行时多态；5. 基类析构函数必须为虚函数，否则delete基类指针时派生类析构函数不会被调用，导致资源泄漏；6. 纯虚函数通过=0声明，使类成为抽象类，强制派生类实现该函数，用于定义接口规范。该机制虽带来轻微性能开销，但极大提升了系统灵活性与可扩展性。
在C++中实现虚函数，核心就是通过
virtual关键字来声明基类中的成员函数，从而开启C++的动态绑定（或运行时多态）机制。简单来说，它让程序在运行时，根据对象的实际类型而非指针或引用的声明类型，来调用正确的函数版本。这对于构建灵活、可扩展的面向对象系统至关重要，也是C++多态性的基石。
解决方案
要实现一个虚函数，你只需要在基类的成员函数声明前加上
virtual关键字。派生类如果重写（override）了这个函数，就不需要再次声明
virtual，但通常为了清晰和可读性，我们也会加上。
下面是一个基本的例子：
#include#include // 基类 class Animal { public: // 声明一个虚函数 virtual void speak() const { std::cout << "Animal makes a sound." << std::endl; } // 虚析构函数，非常重要！ virtual ~Animal() { std::cout << "Animal destructor called." << std::endl; } }; // 派生类 Dog class Dog : public Animal { public: // 重写基类的虚函数 void speak() const override { // 使用 override 关键字是个好习惯，编译器会检查是否真的重写了虚函数 std::cout << "Dog barks: Woof! Woof!" << std::endl; } ~Dog() override { std::cout << "Dog destructor called." << std::endl; } }; // 派生类 Cat class Cat : public Animal { public: void speak() const override { std::cout << "Cat meows: Meow!" << std::endl; } ~Cat() override { std::cout << "Cat destructor called." << std::endl; } }; int main() { Animal* myAnimal = new Animal(); Animal* myDog = new Dog(); // 基类指针指向派生类对象 Animal* myCat = new Cat(); // 基类指针指向派生类对象 myAnimal->speak(); // 输出: Animal makes a sound. myDog->speak(); // 输出: Dog barks: Woof! Woof! (动态绑定生效) myCat->speak(); // 输出: Cat meows: Meow! (动态绑定生效) std::cout << "\n--- Deleting objects ---\n"; delete myAnimal; delete myDog; // 如果Animal的析构函数不是虚函数，这里可能只会调用Animal的析构函数，导致Dog的析构函数未被调用，造成资源泄露。 delete myCat; return 0; }
在这个例子中，
speak()函数被声明为虚函数。当通过
Animal*类型的指针调用
speak()时，C++的动态绑定机制会根据指针实际指向的对象类型（
Dog或
Cat）来调用对应的
speak()实现。如果没有
virtual关键字，
myDog->speak()和
myCat->speak()都会调用
Animal类的
speak()，这就失去了多态的意义。
立即学习“C++免费学习笔记（深入）”；
C++虚函数的工作原理：vtable和vptr究竟扮演了什么角色？
要理解虚函数如何实现动态绑定，就不得不提C++编译器在幕后为我们做的一些“手脚”——虚函数表（vtable）和虚函数表指针（vptr）。我个人觉得，这是C++多态机制最巧妙，也最容易让人感到困惑的地方之一。
当一个类中声明了虚函数，或者继承了带有虚函数的基类时，编译器会为这个类生成一个虚函数表（vtable）。这个vtable本质上是一个函数指针数组，里面存储着该类所有虚函数的地址。每个对象（如果它的类有虚函数）在创建时，都会在它的内存布局中包含一个指向这个vtable的指针，我们称之为虚函数表指针（vptr）。这个vptr通常是对象内存布局中的第一个成员。
所以，当我们通过一个基类指针（比如
Animal* myDog）调用一个虚函数（
myDog->speak()）时，实际的调用过程是这样的：
- 程序首先找到
myDog
指针所指向对象的vptr。 - 通过vptr找到该对象所属类的vtable。
- 在vtable中，根据虚函数在类中声明的顺序（或者说，编译器分配的索引），找到对应虚函数的地址。
- 调用这个地址上的函数。
这个过程发生在运行时，因为vptr指向的vtable是根据对象的实际类型来确定的，所以即使指针类型是基类，也能正确地调用派生类的实现。这也就是“动态绑定”的由来。这个机制虽然带来了一点点内存和性能上的开销（每个对象多了一个vptr，每次虚函数调用多了一次间接寻址），但它换来了巨大的设计灵活性，我觉得这绝对是值得的。
为什么虚析构函数在C++多态中如此关键？
这是一个C++初学者经常踩的坑，也是面试中常被问到的点。简单来说，如果基类的析构函数不是虚函数，而你通过基类指针删除一个派生类对象，那么可能只会调用基类的析构函数，而派生类的析构函数则不会被调用。这听起来可能没啥大不了，但想想看，如果派生类在析构函数中释放了它自己独有的资源（比如动态分配的内存、文件句柄、网络连接等），那么这些资源就永远不会被释放，造成内存泄漏或资源泄漏。
我们来模拟一下这种情况：
#include#include class Base { public: Base() { std::cout << "Base constructor called.\n"; } // 如果这里没有 virtual 关键字 // ~Base() { std::cout << "Base destructor called.\n"; } virtual ~Base() { std::cout << "Base destructor called.\n"; } // 正确的做法 }; class Derived : public Base { private: int* data; public: Derived() : data(new int[10]) { std::cout << "Derived constructor called. Allocating data.\n"; } ~Derived() override { delete[] data; // 释放派生类独有的资源 std::cout << "Derived destructor called. Deallocating data.\n"; } }; int main() { Base* obj = new Derived(); // 基类指针指向派生类对象 // ... 使用 obj ... delete obj; // 问题就出在这里！ return 0; }
如果
Base的析构函数没有
virtual，
delete obj;只会调用
Base::~Base()。
Derived类的析构函数
~Derived()中的
delete[] data;永远不会执行，导致
data指向的内存泄漏。当我第一次遇到这个问题时，感觉C++真是“处处是陷阱”，但理解了背后的机制后，也觉得这种设计是有其道理的，它给了开发者足够的控制权。所以，只要你计划通过基类指针来删除派生类对象，那么基类的析构函数就必须是虚函数。这几乎成了一个C++编程的“黄金法则”。
纯虚函数与抽象类：C++如何强制派生类实现特定行为？
虚函数提供了一种“可选”的重写机制，而纯虚函数则是一种“强制”的机制。当你希望基类定义一个接口，但又不提供这个接口的默认实现，并且强制所有派生类都必须提供自己的实现时，纯虚函数就派上用场了。
纯虚函数的声明方式是在虚函数声明的末尾加上
= 0：
#include// 抽象基类 class Shape { public: // 纯虚函数：声明一个接口，但没有实现 virtual double area() const = 0; virtual void draw() const = 0; // 抽象类可以有非纯虚函数和成员变量 void printInfo() const { std::cout << "This is a shape." << std::cout; } virtual ~Shape() { // 抽象类也应该有虚析构函数 std::cout << "Shape destructor called.\n"; } }; // 派生类 Circle class Circle : public Shape { private: double radius; public: Circle(double r) : radius(r) {} // 必须实现所有纯虚函数 double area() const override { return 3.14159 * radius * radius; } void draw() const override { std::cout << "Drawing a circle with radius " << radius << std::endl; } ~Circle() override { std::cout << "Circle destructor called.\n"; } }; // 派生类 Rectangle class Rectangle : public Shape { private: double width; double height; public: Rectangle(double w, double h) : width(w), height(h) {} double area() const override { return width * height; } void draw() const override { std::cout << "Drawing a rectangle with width " << width << " and height " << height << std::endl; } ~Rectangle() override { std::cout << "Rectangle destructor called.\n"; } }; int main() { // Shape s; // 错误：不能实例化抽象类！ Shape* s1 = new Circle(5.0); Shape* s2 = new Rectangle(4.0, 6.0); s1->draw(); std::cout << "Circle area: " << s1->area() << std::endl; s2->draw(); std::cout << "Rectangle area: " << s2->area() << std::endl; delete s1; delete s2; return 0; }
任何包含至少一个纯虚函数的类都被称为抽象类。抽象类不能被直接实例化（你不能创建
Shape类型的对象），它只能作为基类来使用。它的主要目的是为派生类提供一个统一的接口规范。派生类如果想成为一个“具体类”（可以被实例化的类），就必须实现（override）基类中的所有纯虚函数。否则，派生类自己也会变成一个抽象类。
这种机制在设计模式中非常常见，比如策略模式、模板方法模式等。它能帮助我们构建一个清晰的类层次结构，强制未来的开发者遵循特定的设计约定，这对于大型项目的代码维护性和可读性来说，无疑是极大的提升。我个人在设计一些库的时候，就非常喜欢用抽象类来定义核心功能接口，让使用者去实现具体的细节，这真的能让代码结构清晰很多。
