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::fun
    b2.fun();  // 动态绑定：调用divide::fun
    b3.fun();  // 静态绑定：调用base::fun
    return 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"; }