Fonctions virtuelles C++ et répartition dynamique : comprendre le mécanisme d'appel des méthodes d'exécution

Les fonctions virtuelles permettent aux classes dérivées de remplacer les méthodes de la classe de base, et la répartition dynamique détermine quelle fonction appeler au moment de l'exécution en fonction du type d'objet. Les étapes spécifiques incluent : déclarer des fonctions virtuelles via virtual, permettant aux classes dérivées de les remplacer. Remplacez les fonctions virtuelles dans les classes dérivées pour fournir des implémentations spécifiques. Appelez une fonction virtuelle à l'aide d'un pointeur ou d'une référence à un objet, et le compilateur trouvera et exécutera la fonction correcte dans la table de fonctions virtuelles en fonction du type d'objet au moment de l'exécution.

Fonctions virtuelles C++ et répartition dynamique : compréhension du mécanisme d'appel de méthode d'exécution

Introduction

Les fonctions virtuelles sont une fonctionnalité puissante en C++ qui permet de remplacer les méthodes des classes de base dans les classes dérivées. Cet article approfondira les mécanismes des fonctions virtuelles et de la répartition dynamique, et les démontrera à travers des cas pratiques.

Fonctions virtuelles

Les fonctions virtuelles sont déclarées en ajoutant le mot-clé virtual avant la déclaration de la fonction. Cela indique que la fonction peut être remplacée dans les classes dérivées. Lorsqu'une fonction virtuelle sur un objet est appelée, la fonction réelle appelée est déterminée en fonction du type d'objet lors de l'exécution du programme. virtual 关键字声明的。这表明该函数可以在派生类中被重写。当调用一个对象上的虚拟函数时，实际调用的函数是根据程序运行时的对象类型决定的。

动态调派

动态调派是使用虚函数的一种机制，它允许在运行时确定要调用的函数。当调用一个对象的虚拟函数时，编译器会在对象所属类的虚函数表中查找该函数，并执行找到的函数。

实战案例

以下是一个演示虚拟函数和动态调派的实战案例：

#include <iostream>

class Shape {
public:
    virtual double area() = 0; // 纯虚函数
};

class Rectangle : public Shape {
public:
    Rectangle(double width, double height) : _width(width), _height(height) {}
    double area() override { return _width * _height; }

private:
    double _width;
    double _height;
};

class Circle : public Shape {
public:
    Circle(double radius) : _radius(radius) {}
    double area() override { return 3.14 * _radius * _radius; }

private:
    double _radius;
};

int main() {
    Shape* shapes[] = { new Rectangle(2, 3), new Circle(4) };
    for (Shape* shape : shapes) {
        std::cout << shape->area() << std::endl; // 动态调派
    }
    return 0;
}

在这个示例中，Shape 是一个抽象基类，它有一个纯虚函数 area()。Rectangle 和 Circle 是派生类，实现了 area() 函数并提供了不同的实现。在 main 函数中，我们创建了一个 Shape 指针数组。虽然这些指针指向不同的类型，但我们能够通过该数组统一调用 area()

Répartition dynamique

La répartition dynamique est un mécanisme utilisant des fonctions virtuelles qui permet de déterminer la fonction à appeler au moment de l'exécution. Lorsqu'une fonction virtuelle d'un objet est appelée, le compilateur recherche la fonction dans la table des fonctions virtuelles de la classe à laquelle appartient l'objet et exécute la fonction trouvée.

🎜Un cas pratique🎜🎜🎜Ce qui suit est un cas pratique illustrant les fonctions virtuelles et la répartition dynamique : 🎜rrreee🎜Dans cet exemple, Shape est une classe de base abstraite, qui a une fonction virtuelle purezone(). Rectangle et Circle sont des classes dérivées qui implémentent la fonction area() et fournissent différentes implémentations. Dans la fonction main, nous créons un tableau de pointeurs Shape. Bien que ces pointeurs pointent vers des types différents, nous pouvons appeler la fonction area() uniformément via le tableau, et le compilateur exécutera la fonction correcte dans la classe dérivée appropriée en fonction du type d'exécution. 🎜🎜🎜Conclusion🎜🎜🎜Les fonctions virtuelles et la répartition dynamique sont des mécanismes puissants en C++ qui permettent une invocation de méthode flexible et un polymorphisme d'exécution. Comprendre ces mécanismes est essentiel pour écrire du code robuste et évolutif. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!