override specifier (since C++11)

Spécifie qu'une fonction virtuelle remplace une autre fonction virtuelle.

Syntaxe

L'identifiant override , s'il est utilisé, apparaît immédiatement après le déclarateur dans la syntaxe d'une déclaration de fonction membre ou d'une définition de fonction membre à l'intérieur d'une définition de classe.

Dans les deux cas, virt-specifier-seq , si utilisé, est soit override ou final , soit final override ou override final .

Explication

Dans une déclaration ou définition de fonction membre, override garantit que la fonction est virtuelle et qu'elle redéfinit une fonction virtuelle d'une classe de base. Le programme est mal formé (une erreur de compilation est générée) si cette condition n'est pas respectée.

override est un identifiant ayant une signification particulière lorsqu'il est utilisé après les déclarateurs de fonction membre ; ce n'est pas un mot-clé réservé autrement.

Mots-clés

override

Exemple

#include <iostream>
struct A
{
    virtual void foo();
    void bar();
    virtual ~A();
};
// définitions des fonctions membres de la structure A :
void A::foo() { std::cout << "A::foo();\n"; }
A::~A() { std::cout << "A::~A();\n"; }
struct B : A
{
//  void foo() const override; // Erreur : B::foo ne remplace pas A::foo
                               // (incompatibilité de signature)
    void foo() override; // OK : B::foo remplace A::foo
//  void bar() override; // Erreur : A::bar n'est pas virtuelle
    ~B() override; // OK : `override` peut aussi être appliqué aux
                   // fonctions membres spéciales virtuelles, ex. destructeurs
    void override(); // OK, nom de fonction membre, pas un mot-clé réservé
};
// définitions des fonctions membres de la structure B :
void B::foo() { std::cout << "B::foo();\n"; }
B::~B() { std::cout << "B::~B();\n"; }
void B::override() { std::cout << "B::override();\n"; }
int main()
{
    B b;
    b.foo();
    b.override(); // OK, appelle la fonction membre `override()`
    int override{42}; // OK, définit une variable entière
    std::cout << "override: " << override << '\n';
}

B::foo();
B::override();
override: 42
B::~B();
A::~A();

Voir aussi