Fonctions virtuelles C++ et héritage : comprendre les mystères de l'héritage polymorphe

Les fonctions virtuelles et l'héritage permettent le polymorphisme dans la programmation orientée objet : la déclaration de fonctions virtuelles permet aux classes dérivées de remplacer les méthodes de la classe de base et de les appeler en fonction du type d'exécution de l'objet. L'héritage établit une hiérarchie de classes et les classes dérivées peuvent accéder et étendre les données et méthodes des classes de base. L'héritage polymorphe permet à une classe dérivée d'hériter de plusieurs classes de base, rendant ainsi toutes les fonctions virtuelles de la classe de base disponibles pour l'objet dérivé. L'ordre dans lequel les fonctions virtuelles sont appelées dépend de l'ordre dans lequel la classe est déclarée.

Fonctions virtuelles et héritage C++ : Comprendre les mystères de l'héritage polymorphe

Vue d'ensemble

Dans la programmation orientée objet, les fonctions virtuelles et l'héritage sont des éléments clés du polymorphisme. Les fonctions virtuelles permettent à une classe dérivée de remplacer les méthodes d'une classe de base et d'appeler l'implémentation correcte au moment de l'exécution. L'héritage établit une relation hiérarchique entre les classes afin que les classes dérivées puissent accéder et étendre les données et les méthodes de la classe de base. Cet article approfondira le mécanisme des fonctions virtuelles et de l'héritage en C++ et l'illustrera à travers des cas pratiques.

Fonction virtuelle

Une fonction virtuelle est une fonction membre déclarée comme virtuelle. Lorsqu'une fonction virtuelle est appelée à partir d'une classe dérivée, l'implémentation correcte de la fonction est appelée en fonction du type d'exécution réel de l'objet. virtual。当从派生类调用虚拟函数时，将根据对象的实际运行时类型调用该函数的正确实现。

声明虚拟函数：

class Base {
public:
    virtual void display() {
        cout << "Base class display" << endl;
    }
};

重写派生类中的虚拟函数：

class Derived : public Base {
public:
    virtual void display() { // 重写 display 方法
        cout << "Derived class display" << endl;
    }
};

继承

继承允许派生类从基类继承数据和方法。

继承语法：

class Derived : public Base {
    // 派生类声明
};

派生类可以访问和使用基类中的所有非私有成员，包括虚拟函数。它也可以在派生类中重写基类的虚拟函数。

多态继承

多态继承：当一个派生类从多个基类继承时。

在多态继承中，最派生类的对象可以访问和使用所有基类的虚拟函数。跨多个继承层次调用的顺序取决于类的声明顺序。

实战案例：

考虑以下代码，展示了多态继承的使用：

#include <iostream>

using namespace std;

class Shape {
public:
    virtual void draw() {
        cout << "Drawing shape" << endl;
    }
};

class Circle : public Shape {
public:
    virtual void draw() {
        cout << "Drawing circle" << endl;
    }
};

class Square : public Shape {
public:
    virtual void draw() {
        cout << "Drawing square" << endl;
    }
};

int main() {
    Shape* shapes[] = { new Circle(), new Square() };

    for (Shape* shape : shapes) {
        shape->draw();
    }

    return 0;
}

输出：

Drawing circle
Drawing square

在该例中，Circle 和 Square 类从基类 Shape 继承了 draw 虚拟函数。当调用 draw

Déclarer des fonctions virtuelles :🎜rrreee🎜Remplacer les fonctions virtuelles dans les classes dérivées :🎜rrreee🎜Héritage 🎜🎜L'héritage permet à une classe dérivée d'hériter des données et des méthodes d'une classe de base . 🎜🎜Syntaxe d'héritage :🎜rrreee🎜Une classe dérivée peut accéder et utiliser tous les membres non privés de la classe de base, y compris les fonctions virtuelles. Il peut également remplacer les fonctions virtuelles de la classe de base dans la classe dérivée. 🎜🎜Héritage polymorphe🎜🎜Héritage polymorphe : Lorsqu'une classe dérivée hérite de plusieurs classes de base. 🎜🎜Dans l'héritage polymorphe, la plupart des objets de la classe dérivée peuvent accéder et utiliser toutes les fonctions virtuelles de la classe de base. L'ordre des appels sur plusieurs hiérarchies d'héritage dépend de l'ordre de déclaration des classes. 🎜🎜Exemple pratique :🎜🎜Considérons le code suivant, démontrant l'utilisation de l'héritage polymorphe : 🎜rrreee🎜Sortie :🎜rrreee🎜Dans cet exemple, Encerclez le Les classes et Square héritent de la fonction virtuelle draw de la classe de base Shape. Lorsque la fonction draw est appelée, elle appelle l'implémentation appropriée en fonction du type de l'objet réel. Cela montre comment l'héritage polymorphe permet à une classe dérivée de remplacer les fonctions virtuelles héritées d'une classe de base et de fournir une implémentation correcte spécifique à l'objet au moment de l'exécution. 🎜

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!