Explication détaillée des fonctions virtuelles C++ : résoudre le mystère du mécanisme polymorphe

Les fonctions virtuelles C++ sont la clé pour réaliser le polymorphisme, qui permet aux classes dérivées de remplacer le comportement des classes parentes : déclarées comme fonctions virtuelles et apparaissent dans les classes dérivées. Lorsqu'il est appelé, le compilateur résout dynamiquement la version de fonction correcte en fonction du type d'objet. Les fonctions virtuelles pures obligent les classes dérivées à fournir leur propre implémentation pour réaliser le polymorphisme. Les classes dérivées remplacent les fonctions virtuelles de la classe de base pour implémenter différents comportements.

Explication détaillée des fonctions virtuelles C++ : résoudre le mystère du mécanisme du polymorphisme

Introduction
Le polymorphisme est la pierre angulaire de la programmation orientée objet, qui permet de traiter des objets ayant la même classe parent de différentes manières . Le polymorphisme en C++ est principalement implémenté via des fonctions virtuelles. Cet article approfondira les fonctions virtuelles et démystifiera le mécanisme polymorphe.

L'essence des fonctions virtuelles
Une fonction virtuelle est un type spécial de fonction membre qui est déclarée comme fonction virtuelle et apparaît dans un objet d'une classe dérivée. Lorsqu'une fonction virtuelle est appelée, le compilateur résout dynamiquement la version correcte de la fonction au moment de l'exécution en fonction du type réel de l'objet. Cette fonctionnalité permet aux classes dérivées de remplacer le comportement de la classe parent, réalisant ainsi le polymorphisme.

Grammaire
La syntaxe de déclaration d'une fonction virtuelle est la suivante :

virtual 返回值类型 函数名(参数列表);

Par exemple :

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

Fonction virtuelle pure
Une fonction virtuelle pure est une fonction virtuelle spéciale qui n'a pas de corps de fonction et doit être implémentée dans une classe dérivée. Cela force les classes dérivées à fournir leur propre implémentation, renforçant ainsi le polymorphisme.

Cas
Pour montrer des fonctions virtuelles en action, considérons une classe abstraite de forme Shape et ses deux classes dérivées Circle et Rectangle</ code> : <code>Shape 和其两个派生类 Circle 和 Rectangle：

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

class Circle : public Shape {
public:
    Circle(double radius) : _radius(radius) {}
    double面积() const override { return M_PI * _radius * _radius; }
private:
    double _radius;
};

class Rectangle : public Shape {
public:
    Rectangle(double width, double height) : _width(width), _height(height) {}
    double面积() const override { return _width * _height; }
private:
    double _width, _height;
};

int main() {
    Shape* circle = new Circle(5.0);
    Shape* rectangle = new Rectangle(10.0, 5.0);

    // 父类指针指向不同的派生类对象，但调用正确的面积函数版本
    double areaCircle = circle->面积();
    double areaRectangle = rectangle->面积();

    std::cout << "圆的面积：" << areaCircle << std::endl;
    std::cout << "矩形的面积：" << areaRectangle << std::endl;

    return 0;
}

在这个例子中，Shape 类声明了一个纯虚函数 面积()。派生类 Circle 和 Rectangle 分别覆盖了该函数，实现了各自的面积计算。在 main 函数中，通过父类指针访问派生类对象，并调用 面积()rrreee

Dans cet exemple, la classe Shape déclare une fonction virtuelle pure Area(). Les classes dérivées Circle et Rectangle couvrent respectivement cette fonction et implémentent leurs calculs de surface respectifs. Dans la fonction main, l'objet de classe dérivé est accessible via le pointeur de classe parent et la fonction area() est appelée, mais la version correcte de la fonction est exécutée en fonction de le type réel de l'objet. 🎜

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!