c++如何实现虚函数_c++多态核心之虚函数工作原理-C++-PHP中文网

C++中实现虚函数需在基类方法前加virtual关键字，通过vtable和vptr实现运行时多态，确保基类指针调用派生类重写方法；同时应将基类析构函数声明为虚函数，以防止内存泄漏。

c++如何实现虚函数_c++多态核心之虚函数工作原理

C++中实现虚函数，核心在于在基类的方法声明前加上

virtual

登录后复制

关键字。这不仅仅是一个语法糖，它背后是C++实现运行时多态的关键机制，即通过虚函数表（vtable）和虚指针（vpter）来确保在通过基类指针或引用调用方法时，能够正确执行派生类的重写版本。说白了，虚函数就是为了让你的代码在运行时能“聪明”地知道该调哪个具体的方法，而不是在编译时就铁板一块地定死。

解决方案

要让C++实现虚函数并发挥多态性，你需要遵循几个步骤，这其实很简单，但理解其背后的原理会让你的代码更健壮、更符合面向对象的设计思想。

首先，在你的基类中，你需要将那些你希望派生类能够重写，并且在通过基类指针或引用调用时能表现出多态行为的方法声明为

virtual

登录后复制

。

#include <iostream>
#include <vector>
#include <memory> // for std::unique_ptr

// 基类
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 关键字是C++11引入的，用于明确指出这是对基类虚函数的重写
        std::cout << "Dog barks: Woof! Woof!" << std::endl;
    }

    ~Dog() {
        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() {
        std::cout << "Cat destructor called." << std::endl;
    }
};

int main() {
    // 使用基类指针指向派生类对象
    Animal* myDog = new Dog();
    Animal* myCat = new Cat();
    Animal* genericAnimal = new Animal();

    myDog->speak();          // 输出: Dog barks: Woof! Woof!
    myCat->speak();          // 输出: Cat meows: Meow~
    genericAnimal->speak();  // 输出: Animal makes a sound.

    // 清理内存
    delete myDog;
    delete myCat;
    delete genericAnimal;

    std::cout << "--- Using std::vector and smart pointers ---" << std::endl;

    std::vector<std::unique_ptr<Animal>> animals;
    animals.push_back(std::make_unique<Dog>());
    animals.push_back(std::make_unique<Cat>());
    animals.push_back(std::make_unique<Animal>());

    for (const auto& animalPtr : animals) {
        animalPtr->speak();
    }
    // unique_ptr 会在超出作用域时自动调用析构函数，正确地释放内存。
    // 如果Animal的析构函数不是虚的，这里会导致问题。

    return 0;
}

登录后复制

在这个例子中，

Animal

登录后复制

类的

speak()

登录后复制

方法被声明为

virtual

登录后复制

。

Dog

登录后复制

和

Cat

登录后复制

类都重写了

speak()

登录后复制

方法。当我们在

main

登录后复制

函数中通过

Animal*

登录后复制

类型的指针调用

speak()

登录后复制

时，即使指针类型是

Animal*

登录后复制

，程序也能在运行时根据实际指向的对象类型（

Dog

登录后复制

或

Cat

登录后复制

）来调用正确的

speak()

登录后复制

版本。这就是虚函数带来的运行时多态。

立即学习“C++免费学习笔记（深入）”；

为什么C++需要虚函数来实现多态？

这个问题其实触及了C++对象模型的一个核心。在C++中，默认情况下，函数的调用是静态绑定的，也就是在编译时就确定了要调用哪个函数。这意味着，如果你有一个基类指针指向一个派生类对象，然后你调用这个指针上的一个非虚函数，那么编译器会根据指针的静态类型（基类类型）来决定调用基类的函数，而不是派生类的函数。这在很多场景下是不可接受的，因为它违背了面向对象编程中“一个接口，多种实现”的原则。

想象一下，你有一个

Shape

登录后复制

基类，它有一个

draw()

登录后复制

方法。如果你有

Circle

登录后复制

和

Square

登录后复制

两个派生类，它们都有自己独特的

draw()

登录后复制

实现。如果你通过

Shape*

登录后复制

指针去调用

draw()

登录后复制

，你肯定希望它能画出实际的

Circle

登录后复制

或

Square

登录后复制

，而不是一个通用的“形状”。如果

draw()

登录后复制

不是虚函数，那么无论你的

Shape*

登录后复制

实际指向的是

Circle

登录后复制

还是

Square

登录后复制

，它都会调用

Shape

登录后复制

类的

draw()

登录后复制

方法，这显然不是我们想要的。

虚函数就是为了解决这个问题而生的。它告诉编译器：“嘿，这个函数在运行时可能需要根据对象的实际类型来决定调用哪个版本，别急着在编译时就定死。”通过引入虚函数，C++将函数的绑定从编译时（静态绑定）推迟到了运行时（动态绑定），从而实现了真正的运行时多态。这使得我们能够编写更加灵活、可扩展的代码，符合开放-封闭原则（对扩展开放，对修改封闭）。

虚函数表（vtable）和虚指针（vpter）是如何协同工作的？

要搞清楚虚函数的工作原理，就不得不提虚函数表（vtable）和虚指针（vpter）这两个幕后英雄。它们是C++实现动态绑定的核心机制。

说白了，当一个类中声明了虚函数，或者它继承了一个带有虚函数的基类时，编译器就会为这个类生成一个虚函数表（vtable）。这个vtable本质上是一个函数指针数组，数组的每个元素都指向该类中一个虚函数的实际实现地址。如果派生类重写了某个虚函数，那么vtable中对应的条目就会指向派生类的实现；如果没有重写，它就会指向基类的实现。

与此同时，这个类的每一个对象都会在它的内存布局中多出一个隐藏的虚指针（vpter）。这个vpter是一个指向该类vtable的指针。这个指针通常是对象内存布局的第一个成员（或者某个固定偏移量处）。

阿里云-虚拟数字人

阿里云-虚拟数字人是什么？ ...

查看详情

现在，我们来看它们是如何协同工作的：

对象创建时：当你创建一个带有虚函数的类的对象时（无论是基类对象还是派生类对象），这个对象的vpter会被初始化，指向其对应类的vtable。例如，创建一个
```
Dog
```
登录后复制
对象，它的vpter就会指向
```
Dog
```
登录后复制
类的vtable。
虚函数调用时：当你通过一个基类指针（比如
```
Animal* myDog = new Dog();
```
登录后复制
）调用一个虚函数时（比如
```
myDog->speak();
```
登录后复制
），编译器会执行以下步骤：
- 首先，它会找到
```
myDog
```
  登录后复制
  指针所指向的实际对象的内存地址。
- 接着，它会从这个对象的内存起始位置（或者固定偏移量）取出那个隐藏的vpter。
- 这个vpter指向了该对象实际类型的vtable。
- 然后，编译器会在vtable中查找
```
speak()
```
  登录后复制
  函数对应的条目（每个虚函数在vtable中都有一个固定的索引）。
- 找到这个条目后，它就得到了
```
speak()
```
  登录后复制
  函数在当前对象实际类型中的真实地址。
- 最后，它通过这个地址调用函数。

所以，

myDog->speak()

登录后复制

的调用过程，实际上是

(*(myDog->vpter[index_of_speak]))(myDog)

登录后复制

这样的一个动态查找和调用过程。正是这个vpter和vtable的巧妙配合，使得C++能够在运行时根据对象的实际类型，而非指针的静态类型，来调用正确的虚函数实现，从而实现了多态。当然，这种机制也带来了一点点运行时开销（查找vtable），以及每个对象多了一个指针的内存开销，但这通常是实现多态所必须付出的代价。

纯虚函数和抽象类在多态设计中的作用是什么？

在C++的多态设计中，纯虚函数和抽象类扮演着“定义接口”和“强制实现”的角色，它们是更高级别的多态抽象。

纯虚函数，顾名思义，它是一个没有具体实现的虚函数。你在声明一个虚函数时，如果在其后面加上

= 0

登录后复制

，它就变成了纯虚函数。

class Shape {
public:
    // 纯虚函数，表示所有形状都“应该”有绘制行为，但基类本身无法提供具体实现
    virtual void draw() const = 0; 

    virtual ~Shape() {} // 虚析构函数仍然是推荐的
};

登录后复制

一个类中只要包含一个或多个纯虚函数，那么这个类就自动成为了抽象类。抽象类有以下几个关键特性：

不能被直接实例化：你不能创建抽象类的对象（例如
```
Shape s;
```
登录后复制
或
```
Shape* s = new Shape();
```
登录后复制
）。因为抽象类中存在未实现的纯虚函数，它本身是不完整的。
定义接口：抽象类主要用于定义一个接口或者一个契约。它规定了所有派生类“必须”实现的行为。比如
```
Shape
```
登录后复制
类中的
```
draw()
```
登录后复制
纯虚函数，就强制所有从
```
Shape
```
登录后复制
派生的类（如
```
Circle
```
登录后复制
、
```
Square
```
登录后复制
）都必须提供自己的
```
draw()
```
登录后复制
实现。
作为基类使用：抽象类只能作为基类来使用，它的作用就是为派生类提供一个统一的接口规范。只有当派生类实现了基类中所有的纯虚函数后，它才能被实例化。如果派生类没有实现所有的纯虚函数，那么它自身也会成为一个抽象类。

纯虚函数和抽象类在多态设计中的作用非常明确：它们允许你设计一个顶层概念，这个概念本身可能没有一个通用的、有意义的实现（比如“形状”的

draw()

登录后复制

方法，没有具体形状就无法画），但它强制所有具体化这个概念的子类都必须提供这个实现。这极大地提升了代码的规范性和可维护性，确保了所有遵循这个接口的类都能以一致的方式被操作，是实现多态和面向接口编程的强大工具。

虚析构函数的重要性及其原理

虚析构函数在C++多态中是一个经常被忽视但极其重要的概念，尤其是在涉及动态内存管理时。它的重要性体现在防止内存泄漏和未定义行为上。

问题背景： 设想一下，你有一个基类

Base

登录后复制

和一个派生类

Derived

登录后复制

，

Derived

登录后复制

在构造函数中分配了一些堆内存资源。如果你通过一个基类指针来删除一个派生类对象，并且基类的析构函数不是虚的：

class Base {
public:
    Base() { std::cout << "Base constructor." << std::endl; }
    ~Base() { std::cout << "Base destructor." << std::endl; } // 非虚析构函数
};

class Derived : public Base {
private:
    int* data;
public:
    Derived() : data(new int[10]) { std::cout << "Derived constructor." << std::endl; }
    ~Derived() {
        std::cout << "Derived destructor." << std::endl;
        delete[] data; // 释放派生类分配的资源
    }
};

int main() {
    Base* ptr = new Derived(); // 基类指针指向派生类对象
    delete ptr; // 预期调用Derived的析构函数，然后是Base的析构函数
    return 0;
}

登录后复制

在上述代码中，

delete ptr;

登录后复制

会发生什么？如果

Base

登录后复制

的析构函数不是

virtual

登录后复制

，那么

delete ptr;

登录后复制

会触发静态绑定，编译器会根据

ptr

登录后复制

的静态类型（

Base*

登录后复制

）来调用

Base

登录后复制

的析构函数。结果就是

Derived

登录后复制

的析构函数不会被调用，

data

登录后复制

指向的内存将不会被释放，从而导致内存泄漏。这还只是内存泄漏，更严重的是，这种行为是未定义行为，可能导致程序崩溃或其他不可预测的错误。

虚析构函数的解决方案： 要解决这个问题，只需要将基类的析构函数声明为

virtual

登录后复制

：

class Base {
public:
    Base() { std::cout << "Base constructor." << std::endl; }
    virtual ~Base() { std::cout << "Base destructor." << std::endl; } // 虚析构函数
};

class Derived : public Base {
private:
    int* data;
public:
    Derived() : data(new int[10]) { std::cout << "Derived constructor." << std::endl; }
    ~Derived() {
        std::cout << "Derived destructor." << std::endl;
        delete[] data;
    }
};

int main() {
    Base* ptr = new Derived();
    delete ptr; // 现在会正确调用Derived的析构函数，然后是Base的析构函数
    return 0;
}

登录后复制

现在，当