C++多态与虚函数详解：从入门到精通

C++多态与虚函数详解：从入门到精通

📚 本文深入浅出地讲解C++多态机制，帮助你彻底掌握面向对象编程的核心特性，无论你是初学者还是想要提升的程序员，这篇文章都能让你对C++多态有全新的理解。

一、多态基础知识

1.1 什么是多态？

多态是C++面向对象三大特性（封装、继承、多态）之一，它允许我们用同一个接口处理不同类型的对象。简单来说，多态就是"一个接口，多种实现"。

多态分为两种形式：

• 编译时多态：通过函数重载和运算符重载实现
• 运行时多态：通过虚函数和继承实现（本文重点）

1.2 为什么需要多态？

假设我们在开发一个绘图程序，需要绘制各种形状（圆形、矩形、三角形等）。如果没有多态，我们可能需要为每种形状编写单独的绘制函数：

void drawCircle(Circle* c) { /* 绘制圆形 */ }
void drawRectangle(Rectangle* r) { /* 绘制矩形 */ }
void drawTriangle(Triangle* t) { /* 绘制三角形 */ }

而有了多态，我们只需要一个函数：

void draw(Shape* s) { s->draw(); } // Shape是所有形状的基类

这大大提高了代码的可维护性和扩展性。

二、虚函数与动态绑定实战

2.1 多继承下的虚函数覆盖

先看一个经典案例，理解虚函数的基本用法：

#include<iostream>
using namespace std;class A {
public:virtual void who() { // 声明为虚函数，支持动态绑定cout << "who in A" << endl;}
};class B {
public:void who() { // 普通成员函数，只能静态绑定cout << "who in B" << endl;}
};class C : public A, public B { // 多继承
public:void who() override { // 使用override关键字明确表示覆盖基类虚函数cout << "who in C" << endl;}void Fun1(A &f) { // 通过A类引用调用who方法f.who();}void Fun2(B &m) { // 通过B类引用调用who方法m.who();}
};int main() {C obj;obj.Fun1(obj); // 动态绑定：调用C类的who方法obj.Fun2(obj); // 静态绑定：调用B类的who方法return 0;
}

运行结果与分析：

who in C
who in B

知识点解析：

1. 当基类函数声明为virtual时，派生类可以覆盖该函数
2. 通过基类指针或引用调用虚函数时，会调用实际对象的函数实现（动态绑定）
3. 没有声明为virtual的函数使用静态绑定，编译时就确定调用哪个函数
4. override关键字（C++11新增）帮助编译器检查是否正确覆盖了虚函数

💡 核心概念：虚函数表（vtable）是C++实现动态绑定的机制，每个包含虚函数的类都有一个虚函数表，存储指向虚函数实现的指针。

2.2 虚函数与函数重载的区别

很多初学者容易混淆虚函数覆盖与函数重载，下面通过实例区分：

#include<iostream>
using namespace std;class base {
public:virtual void f1() { cout << "B "; } // 虚函数virtual void f2() { cout << "B "; } // 虚函数
};class derive : public base {
public:void f1() override { cout << "D "; } // 正确覆盖基类虚函数void f2(int x = 0) { cout << "D "; } // 这是重载而非覆盖！参数列表不同
};int main() {base bb, *p = &bb;p->f1(); // 输出：B（调用base::f1）p->f2(); // 输出：B（调用base::f2）derive dd;p = &dd; // 基类指针指向派生类对象p->f1(); // 输出：D（动态绑定到derive::f1）p->f2(); // 输出：B（注意：派生类f2未覆盖基类f2，因为参数不同）return 0;
}

运行结果与分析：

B B D B

重要提示：

• 虚函数覆盖要求函数名、参数列表、返回类型完全相同
• 派生类的f2(int)与基类的f2()是不同的函数（重载），不会触发动态绑定
• 通过基类指针调用f2()时，找不到匹配的覆盖函数，所以调用基类版本

⚠️ 常见错误：函数签名（参数列表、返回值）不完全一致时，不会发生覆盖，而是形成重载。使用override关键字可以帮助避免这类错误。

2.3 常成员函数的虚函数覆盖

const关键字也是虚函数覆盖必须考虑的因素：

#include<iostream>
using namespace std;class base {
public:virtual int fun(void) const { // const修饰的虚函数cout << "base::fun" << endl;return 10;}
};class divide : public base {
public:int fun(void) const override { // 覆盖必须保持const属性一致cout << "divide::fun" << endl;return 20;}
};int main() {divide d;base *b1 = &d;     // 通过指针实现多态base &b2 = d;      // 通过引用实现多态base b3;           // 基类对象b1->fun(); // 动态绑定：调用divide::funb2.fun();  // 动态绑定：调用divide::funb3.fun();  // 静态绑定：调用base::funreturn 0;
}

运行结果与分析：

divide::fun
divide::fun
base::fun

进阶知识点：

1. 常成员函数（const修饰）不允许修改对象的非静态成员
2. 覆盖时必须保持const属性一致，否则不构成覆盖
3. 无论是通过指针还是引用，多态机制的工作方式是一样的

2.4 虚析构函数的重要性

这是C++中最容易导致内存泄漏的陷阱之一：

#include<iostream>
using namespace std;class A {
public:A() { cout << "A::A() called.\n"; }virtual ~A() { cout << "A::~A() called.\n"; }