Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

virtual — fonctions virtuelles et héritage virtuel

Le mot-clé virtual a deux usages distincts : il permet de sélectionner une fonction membre redéfinie selon le type dynamique d’un objet et marque une classe de base virtuelle partagée dans une hiérarchie d’héritage. Aucun de ces mécanismes ne nécessite l’autre.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

struct Base {
    virtual void f();
    virtual void g() = 0;
    virtual ~Base() = default;
};
struct Derived : Base {
    void f() override;
    void g() override;
};
struct Shared : virtual Base {};

virtual, dans la première déclaration d’une fonction membre non statique, permet d’appeler son redéfinisseur final selon le type dynamique de l’objet, y compris via un pointeur ou une référence vers la base. Une redéfinition reste virtuelle sans répéter virtual ; utilisez override pour que le compilateur détecte une incompatibilité. Un appel qualifié tel que ref.Base::name() contourne cette sélection dynamique.

La déclaration virtual void g() = 0; spécifie une fonction virtuelle pure. Une classe dont le redéfinisseur final reste pur est abstraite : on ne peut pas créer d’objets autonomes de cette classe. Une fonction virtuelle pure peut avoir une définition séparée ; un destructeur virtuel pur exige lui aussi une définition lorsqu’il est appelé pendant la destruction d’objets dérivés.

Si des objets dérivés doivent être supprimés via un pointeur vers la base, donnez à celle-ci un destructeur virtuel public, par exemple virtual ~Base() = default;. Avec un delete ordinaire, en l’absence du mécanisme spécialisé destroying delete, l’absence de destructeur virtuel dans cette situation entraîne un comportement indéfini. Pendant la construction et la destruction, les appels virtuels concernant cet objet ne sont pas distribués aux redéfinitions des classes plus dérivées que celle dont le constructeur ou le destructeur est en cours d’exécution.

Par ailleurs, struct Shared : virtual Base {}; spécifie un héritage virtuel. Tous les chemins d’héritage virtuel vers la même base dans l’objet le plus dérivé partagent un seul sous-objet de base ; les chemins non virtuels peuvent ajouter des sous-objets distincts. Cela ne rend pas virtuelles les fonctions de la base.

L’exemple montre la répartition dynamique et un appel explicite à l’implémentation de la base. Cette entrée porte sur C++23 ; le mode de compilation indiqué ne garantit pas une utilisation en production. La source eel.is est un brouillon en évolution, et non une publication C++23 figée.

Exemples

#include <iostream>

struct Base {
    virtual const char* name() const { return "Base"; }
    virtual ~Base() = default;
};

struct Derived : Base {
    const char* name() const override { return "Derived"; }
};

int main() {
    Derived object;
    const Base& ref = object;
    std::cout << ref.name() << '\n';
    std::cout << ref.Base::name() << '\n';
}

Résultat

Derived
Base

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources