在 C++ 中，虚函数（Virtual Function）是一种用于实现多态性的成员函数。通过将一个函数声明为虚函数，基类可以允许派生类重写该函数，并在运行时根据对象的实际类型调用适当的函数版本，而不是编译时确定的函数版本。

虚函数的关键点

  1. 多态性：

    • 虚函数是实现运行时多态性的关键工具。多态性允许同一个接口（即同样的函数调用）根据不同的对象类型表现出不同的行为。

  2. 基类和派生类：

    • 当在基类中声明一个虚函数时，派生类可以重新定义（覆盖）该函数。这种覆盖允许通过基类指针或引用调用派生类的实现。

  3. 虚函数表（VTable）：

    • 当一个类包含虚函数时，编译器会为这个类生成一个虚函数表（VTable），其中包含指向虚函数的指针。每个对象都包含一个指向该虚函数表的指针（通常称为 vptr）。在运行时，C++ 会根据这个虚函数表来决定调用哪个函数。

  4. virtual 关键字：

    • 在基类中，通过 virtual 关键字来声明虚函数。派生类可以覆盖这个函数，而无需再次使用 virtual 关键字。

示例代码

以下是一个简单的虚函数示例，展示了如何实现多态性：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include <iostream>

class Animal {
public:
    // 基类中的虚函数
    virtual void makeSound() {
        std::cout << "Animal makes a sound" << std::endl;
    }
};

class Dog : public Animal {
public:
    // 派生类覆盖虚函数
    void makeSound() override {
        std::cout << "Dog barks" << std::endl;
    }
};

class Cat : public Animal {
public:
    // 派生类覆盖虚函数
    void makeSound() override {
        std::cout << "Cat meows" << std::endl;
    }
};

int main() {
    Animal* animal1 = new Dog(); // 基类指针指向派生类对象
    Animal* animal2 = new Cat();

    // 基类指针调用虚函数，运行时多态性生效
    animal1->makeSound(); // 输出：Dog barks
    animal2->makeSound(); // 输出：Cat meows

    // 清理内存
    delete animal1;
    delete animal2;

    return 0;
}

解释

  • 虚函数声明：在 Animal 类中，makeSound() 函数被声明为虚函数（virtual）。
  • 函数覆盖：Dog 和 Cat 类都覆盖了基类的 makeSound() 函数。
  • 多态性：在 main() 函数中，尽管 animal1 和 animal2 都是 Animal 类型的指针，但由于虚函数的存在，它们在运行时调用了各自对象的 makeSound() 实现。

虚函数的重要性

  1. 实现多态性：虚函数是 C++ 实现运行时多态性的核心机制。通过虚函数，程序可以在运行时根据对象的实际类型决定调用哪个函数版本。

  2. 动态绑定：虚函数使得 C++ 支持动态绑定（又称为后期绑定或运行时绑定），即在程序运行时而不是编译时确定调用哪个函数。

  3. 接口设计：在设计基类时，通过虚函数可以定义一个通用接口，而派生类可以通过覆盖这些虚函数来实现特定的行为。这使得代码更具灵活性和可扩展性。

纯虚函数与抽象类

  • 如果一个虚函数在基类中没有实现，而是希望所有派生类都必须提供自己的实现，可以将该虚函数声明为纯虚函数（Pure Virtual Function）。纯虚函数的声明形式如下：

    1
    virtual void makeSound() = 0;

  • 包含纯虚函数的类称为抽象类（Abstract Class），不能实例化对象，只能作为基类被继承。

小结

  • 虚函数 使得 C++ 能够实现运行时多态性，允许基类定义通用接口，而派生类可以根据需要覆盖和实现这些接口。
  • 使用虚函数可以通过基类指针或引用调用派生类的函数，从而使代码更加灵活和可扩展。

在这段代码中，我们展示了C++中虚函数如何实现运行时的多态性。让我们逐行分析一下代码的关键部分：

代码解析

1
2
3
int main() {
    Animal* animal1 = new Dog(); // 基类指针指向派生类对象
    Animal* animal2 = new Cat();
  • 基类指针指向派生类对象：这里我们创建了两个基类 Animal 的指针 animal1 和 animal2，并分别让它们指向 Dog 和 Cat 的对象。这种做法是多态性的基础，因为它允许我们使用基类指针来引用派生类对象。
1
2
3
// 基类指针调用虚函数，运行时多态性生效
animal1->makeSound(); // 输出：Dog barks
animal2->makeSound(); // 输出：Cat meows
  • 调用虚函数：尽管 animal1 和 animal2 的类型都是 Animal*，但是由于 makeSound() 是一个虚函数，实际调用的函数版本在运行时根据对象的实际类型（Dog 和 Cat）来决定。
    • animal1->makeSound(); 调用 Dog 类的 makeSound() 方法，输出 “Dog barks”。
    • animal2->makeSound(); 调用 Cat 类的 makeSound() 方法，输出 “Cat meows”。
1
2
3
4
5
6
    // 清理内存
    delete animal1;
    delete animal2;

    return 0;
}
  • 清理内存：在 C++ 中，使用 new 动态分配的内存需要使用 delete 来释放。这里我们在程序结束前删除了 animal1 和 animal2 所指向的对象，以防止内存泄漏。

总结

  • 多态性：通过虚函数机制，基类指针 Animal* 能够调用派生类 Dog 和 Cat 的 makeSound() 方法，展示了多态性。
  • 运行时决策：在运行时，C++ 根据指针实际指向的对象类型来决定调用哪个函数，这就是动态绑定或后期绑定的核心。

这个示例很好地展示了C++中虚函数和多态性如何使得代码更加灵活和可扩展。