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

CKTIS / C++

Fonction virtuelle pure (= 0) en C++

La notation `= 0` déclare une fonction membre virtuelle pure. Elle permet de définir une interface abstraite dont les appels peuvent atteindre des implémentations différentes selon le type de l’objet.

Version : ISO C++23; implementation support may vary

Syntaxe

struct Strategy {
    virtual int apply(int x) const = 0;
    virtual ~Strategy() = default;
};

Dans virtual int apply(int x) const = 0;, le spécificateur = 0 rend la fonction membre virtuelle pure. Ce n’est ni une affectation ni une valeur de retour. Une fonction qui en redéfinit une autre peut elle aussi être virtuelle pure : int apply(int x) const override = 0;.

Une classe est abstraite si, pour au moins une fonction virtuelle, la redéfinition finale dans cette classe reste virtuelle pure. On ne peut pas créer d’objet autonome de cette classe, mais un pointeur ou une référence de type de base peut désigner un objet d’une classe dérivée concrète. override aide à repérer les erreurs : sans const, Half::apply ne redéfinit pas Strategy::apply.

Une fonction virtuelle pure peut être définie hors de la classe sans perdre son caractère pur. Un appel qualifié comme strategy.Strategy::apply(12) contourne la répartition dynamique et exige cette définition. Depuis le constructeur ou le destructeur d’une classe abstraite, un appel virtuel direct ou indirect à une fonction virtuelle pure sur l’objet en cours de construction ou de destruction entraîne un comportement indéfini, même si cette fonction est définie.

Le destructeur public virtual ~Strategy() = default; utilise la définition par défaut et n’est pas pur. Il garantit le bon ordre de destruction quand std::unique_ptr<Strategy> supprime un objet unique via Strategy*. Si le destructeur était déclaré virtuel pur avec = 0, il faudrait tout de même le définir hors de la classe dès lors que des objets dérivés sont créés.

print reçoit une const Strategy& au lieu de créer sa propre stratégie. C’est de l’injection de dépendances : l’appel virtuel à apply choisit l’implémentation selon le type réel de l’objet. Un registre de fabriques peut sélectionner des stratégies compilées dans le programme ; la répartition dynamique ne charge pas elle-même de bibliothèques partagées.

Exemples

#include <iostream>
#include <memory>

struct Strategy {
    virtual int apply(int x) const = 0;
    virtual ~Strategy() = default;
};

struct Half : Strategy {
    int apply(int x) const override { return x / 2; }
};

struct Third : Strategy {
    int apply(int x) const override { return x / 3; }
};

void print(const Strategy& strategy) {
    std::cout << strategy.apply(12) << '\n';
}

int main() {
    std::unique_ptr<Strategy> half = std::make_unique<Half>();
    std::unique_ptr<Strategy> third = std::make_unique<Third>();
    print(*half);
    print(*third);
}

Résultat

6
4

`Half` divise `12` par `2` et `Third` par `3`. La même fonction `print` affiche `6`, puis `4`.

Leçons associées

  • C++ · Leçon 59 · Avancé · Version : 3

Sources