C++多态的核心在于虚函数和动态绑定。通过在基类中声明虚函数，编译器会为类生成虚函数表（vtable），每个对象包含指向vtable的虚指针（vptr）。当通过基类指针或引用调用虚函数时，运行时通过vptr查找vtable，确定并调用实际类型的函数版本，实现动态绑定。例如，Shape基类的draw()为虚函数，Circle和Square继承并重写draw()，通过Shape指针调用draw()时，会根据实际对象类型调用对应实现，而非指针声明类型。这支持“开闭原则”，使代码易于扩展而无需修改原有逻辑。与静态绑定（编译时决定调用函数）不同，动态绑定在运行时确定函数地址，带来灵活性但有轻微性能开销。使用多态需注意：基类析构函数应为虚函数，以防资源泄漏；避免对象切片，应使用引用或指针传递；构造和析构函数中调用虚函数不会触发多态；使用override确保正确重写，final限制继承或重写，提升代码安全性和可维护性。
C++多态的实现，核心在于虚函数和动态绑定。它允许你通过基类指针或引用，来操作派生类对象，并且在运行时根据对象的实际类型调用正确的成员函数。这简直是面向对象编程的灵魂所在，让代码变得异常灵活且易于扩展。
要实现多态，你需要在基类中将函数声明为
virtual
。当一个函数被标记为
virtual
后，编译器会为包含虚函数的类生成一个虚函数表（vtable）。每个对象会有一个虚指针（vptr），指向这个vtable。当通过基类指针或引用调用虚函数时，系统会在运行时通过vptr找到对应的vtable，再从vtable中找到并调用派生类中被重写的函数。这就是所谓的动态绑定，或者运行时多态。
举个例子，想象我们有一系列不同的“图形”：
#include <iostream> #include <vector> #include <memory> // For std::unique_ptr class Shape { public: virtual void draw() const { // 虚函数 std::cout << "Drawing a generic shape." << std::endl; } // 虚析构函数，非常重要，后面会细说 virtual ~Shape() { std::cout << "Shape destructor called." << std::endl; } }; class Circle : public Shape { public: void draw() const override { // override 关键字是个好习惯 std::cout << "Drawing a circle." << std::endl; } ~Circle() { std::cout << "Circle destructor called." << std::endl; } }; class Square : public Shape { public: void draw() const override { std::cout << "Drawing a square." << std::endl; } ~Square() { std::cout << "Square destructor called." << std::endl; } }; // 我们可以这样使用： // int main() { // Shape* s1 = new Circle(); // Shape* s2 = new Square(); // Shape* s3 = new Shape(); // 也可以直接创建基类对象 // // s1->draw(); // 实际调用 Circle::draw() // s2->draw(); // 实际调用 Square::draw() // s3->draw(); // 实际调用 Shape::draw() // // delete s1; // delete s2; // delete s3; // // // 结合智能指针使用更安全 // std::vector<std::unique_ptr<Shape>> shapes; // shapes.push_back(std::make_unique<Circle>()); // shapes.push_back(std::make_unique<Square>()); // shapes.push_back(std::make_unique<Shape>()); // // for (const auto& s : shapes) { // s->draw(); // } // // unique_ptr 会自动管理内存，无需手动delete // return 0; // }
这段代码展示了，即便我们通过基类
Shape
的指针来操作对象，
draw()
函数依然能根据实际指向的派生类类型，调用到正确的实现。这就是多态的魅力。
立即学习“C++免费学习笔记（深入）”；
虚函数在C++面向对象设计中的核心作用是什么？
在我看来，虚函数是C++实现面向对象“开闭原则”（Open/Closed Principle）的关键。它允许你定义一个通用的接口（基类中的虚函数），然后让不同的派生类提供各自的具体实现。这意味着，你可以在不修改现有代码（“封闭”修改）的情况下，轻松地添加新的功能（“开放”扩展）。
想象一下，如果
draw()
不是虚函数，那么
Shape* s = new Circle(); s->draw();
无论如何都会调用
Shape::draw()
，这显然不是我们想要的。虚函数解决了这个问题，它确保了当你通过基类指针或引用操作对象时，调用的总是对象实际类型所对应的函数版本。这使得代码结构更加灵活，易于维护和扩展。比如，你有一个图形编辑器，它需要绘制各种图形。有了多态，你只需要一个
std::vector<Shape*>
（或者更好的，
std::vector<std::unique_ptr<Shape>>
），然后遍历这个vector，对每个元素调用
draw()
，系统就会自动为你绘制出正确的图形，而不需要一大堆
if-else
来判断具体类型。这种设计模式，我觉得是现代软件开发中不可或缺的。
动态绑定（运行时多态）是如何工作的？与静态绑定有何不同？
动态绑定，顾名思义，就是函数调用的决策发生在程序运行时。它的核心机制就是前面提到的虚函数表（vtable）和虚指针（vptr）。每个包含虚函数的类都会有一个vtable，它本质上是一个函数指针数组，存储了该类及其所有基类中虚函数的地址。而每个类的对象会有一个隐藏的vptr，指向其对应类的vtable。当你通过基类指针或引用调用虚函数时，编译器会生成代码，通过对象的vptr找到vtable，再从vtable中查找并调用正确的函数地址。这个过程是在运行时完成的，因此称为动态绑定。
与之相对的是静态绑定（也叫早期绑定或编译时多态）。这是C++函数调用的默认行为，发生在编译阶段。编译器会根据调用者的类型（也就是指针或引用的声明类型）来确定要调用的函数。比如，非虚函数、函数重载以及模板函数，都是静态绑定的例子。
来看个对比：
class Base { public: void nonVirtualFunc() { std::cout << "Base nonVirtualFunc" << std::endl; } virtual void virtualFunc() { std::cout << "Base virtualFunc" << std::endl; } }; class Derived : public Base { public: void nonVirtualFunc() { // 这是一个新的函数，不是重写 std::cout << "Derived nonVirtualFunc" << std::endl; } void virtualFunc() override { std::cout << "Derived virtualFunc" << std::endl; } }; // Base* ptr = new Derived(); // ptr->nonVirtualFunc(); // 静态绑定：调用 Base::nonVirtualFunc() // ptr->virtualFunc(); // 动态绑定：调用 Derived::virtualFunc()
可以看到，尽管
ptr
指向的是
Derived
对象，但由于
nonVirtualFunc
不是虚函数，编译器在编译时就确定了它将调用
Base::nonVirtualFunc()
。而
virtualFunc
因为是虚函数，实际调用的版本则在运行时才确定。
动态绑定虽然带来了极大的灵活性，但也伴随着微小的性能开销，主要是vtable查找的成本。但在绝大多数现代应用程序中，这种开销通常可以忽略不计，相比于它带来的设计优势，这点代价完全值得。
实现C++多态时有哪些常见的坑或需要注意的点？
多态虽然强大，但在实际使用中确实有一些容易踩的“坑”，或者说，需要特别留心的地方：
-
虚析构函数（Virtual Destructors）：这绝对是初学者最容易忽视但又极其关键的一点。如果基类的析构函数不是虚的，当你通过基类指针
delete
一个派生类对象时，只会调用基类的析构函数，而派生类特有的析构函数不会被调用。这会导致派生类中分配的资源（比如动态内存、文件句柄等）无法被正确释放，造成内存泄漏或其他资源泄漏。所以，只要你的类可能被继承，并且可能通过基类指针删除派生类对象，那么基类的析构函数就必须是虚的。
class Base { public: // 如果这里没有 virtual，delete dptr; 将只调用 Base::~Base() virtual ~Base() { std::cout << "Base destructor." << std::endl; } }; class Derived : public Base { public: ~Derived() { std::cout << "Derived destructor." << std::endl; } }; // Base* dptr = new Derived(); // delete dptr; // 如果Base::~Base()不是虚的，Derived::~Derived()不会被调用 -
纯虚函数与抽象类：当你希望某个基类只作为接口而不能被直接实例化时，你可以引入纯虚函数。一个纯虚函数是这样声明的：
virtual void func() = 0;
。只要类中包含至少一个纯虚函数，这个类就变成了抽象类，不能直接创建对象。它只能作为基类被继承，并且派生类必须实现所有纯虚函数，才能成为可实例化的具体类。这对于定义通用行为契约非常有用。
-
对象切片（Object Slicing）：这是一个很隐蔽但破坏性很大的问题。当你将一个派生类对象按值传递给一个期望基类对象的函数时，派生类特有的数据成员会被“切掉”，只剩下基类部分的数据。这完全丢失了多态性。
void processShape(Shape s) { // 按值传递 s.draw(); // 即使传入的是Circle对象，这里也只会调用 Shape::draw() } // Circle c; // processShape(c); // 这里发生了对象切片正确做法是按引用或指针传递：
void processShape(Shape& s)
或
void processShape(Shape* s)
。
-
在构造函数或析构函数中调用虚函数：这是一个非常特殊的规则。在构造函数或析构函数中调用虚函数，是不会发生多态的。在构造函数执行期间，对象还没有完全形成派生类，vtable还没有完全初始化到派生类的状态，因此只会调用当前类（或其基类）的版本。析构函数也类似，在派生类析构完成后，对象已经部分“退化”为基类，所以也不会发生多态。我个人建议，除非你非常清楚你在做什么，否则应避免在构造函数和析构函数中调用虚函数。
-
override
和
final
关键字：C++11引入的
override
关键字，可以帮助编译器检查你是否真的重写了基类的虚函数。如果你拼写错误或者参数列表不匹配，编译器会报错，而不是默默地创建一个新的非虚函数。这极大地提高了代码的健壮性。
final
关键字则可以用来阻止派生类进一步重写某个虚函数，或者阻止一个类被继承。它们都是为了让多态的设计意图更清晰，减少潜在的错误。
理解并规避这些点，能让你在C++多态的道路上走得更稳健。
评论（已关闭）
评论已关闭