Fonctions virtuelles et fonctions virtuelles pures : quelle est la différence ?

Les fonctions virtuelles expliquées : ce qu'elles sont et en quoi elles diffèrent des fonctions virtuelles pures

Dans la programmation orientée objet, le concept de fonctions virtuelles fait partie intégrante du polymorphisme d'exécution. Une fonction virtuelle est une fonction qui peut être remplacée dans les classes dérivées pour fournir différentes implémentations à différents niveaux de la hiérarchie des classes.

La distinction clé entre une fonction virtuelle et une fonction non virtuelle est que la version la plus dérivée est utilisé à tous les niveaux de la hiérarchie des classes lorsqu'une fonction virtuelle est remplacée. En revanche, la fonctionnalité d'une fonction non virtuelle reste inchangée dans la classe de base, même si elle est remplacée dans une classe dérivée.

Voici un exemple pour illustrer le comportement des fonctions virtuelles :

struct Base {
    virtual ~Base() = default;

    virtual void foo() {
        std::cout << "Base::Foo" << std::endl;
    }
};

struct Derived final: Base {
    void foo() override {
        std::cout << "Derived::Foo" << std::endl;
    }
};

L'exécution de ce code produit le résultat suivant :

Base::Foo
Derived::Foo
Derived::Foo

Comme vous pouvez le voir, lorsque la fonction foo() est appelée sur une instance de Classe dérivée, l'implémentation Derived::foo() est utilisée, même lors de l'accès à l'instance via un pointeur de classe de base (Base* dérivé_as_base).

Fonctions virtuelles pures : un cas particulier

Une fonction virtuelle pure est une fonction virtuelle qui doit être implémentée dans des classes dérivées. Il n'est pas défini dans la classe de base et doit être remplacé dans une classe dérivée pour rendre la classe concrète. Une classe avec une ou plusieurs fonctions virtuelles pures est considérée comme abstraite et ne peut pas être instanciée directement.

Voici un exemple de fonction virtuelle pure :

struct Base {
    virtual ~Base() = default;

    virtual void foo() = 0;
};

struct Derived final: Base {
    void foo() override {
        std::cout << "Derived::Foo" << std::endl;
    }
};

Dans ce cas, la classe Base est abstrait car il contient une fonction virtuelle pure foo(). Pour utiliser cette classe, une classe dérivée doit implémenter la fonction foo(), faisant de la classe dérivée une classe concrète qui peut être instanciée.

En résumé, les fonctions virtuelles vous permettent de remplacer les fonctionnalités de la classe de base à différents niveaux de la hiérarchie, tandis que les fonctions virtuelles pures nécessitent que des classes dérivées implémentent des fonctionnalités spécifiques pour rendre la classe concrète. Comprendre ces concepts est crucial pour écrire du code extensible et polymorphe en programmation orientée 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!