Spécificateur de substitution

Vous pouvez utiliser le mot clé override pour désigner les fonctions membres qui remplacent une fonction virtuelle dans une classe de base.

Syntaxe

function-declaration override;

Notes

le remplacement respecte le contexte et a une signification particulière uniquement lorsqu’il est utilisé après une déclaration de fonction membre ; sinon, il ne s’agit pas d’un mot clé réservé.

Exemple

Utilisez la substitution pour empêcher le comportement d’héritage par inadvertance dans votre code. L’exemple suivant montre où, sans utiliser de remplacement, le comportement de la fonction membre de la classe dérivée n’a peut-être pas été prévu. Le compilateur n'émet pas d'erreurs pour ce code.

class BaseClass
{
    virtual void funcA();
    virtual void funcB() const;
    virtual void funcC(int = 0);
    void funcD();
};

class DerivedClass: public BaseClass
{
    virtual void funcA(); // ok, works as intended

    virtual void funcB(); // DerivedClass::funcB() is non-const, so it does not
                          // override BaseClass::funcB() const and it is a new member function

    virtual void funcC(double = 0.0); // DerivedClass::funcC(double) has a different
                                      // parameter type than BaseClass::funcC(int), so
                                      // DerivedClass::funcC(double) is a new member function
};

Lorsque vous utilisez le remplacement, le compilateur génère des erreurs au lieu de créer silencieusement de nouvelles fonctions membres.

class BaseClass
{
    virtual void funcA();
    virtual void funcB() const;
    virtual void funcC(int = 0);
    void funcD();
};

class DerivedClass: public BaseClass
{
    virtual void funcA() override; // ok

    virtual void funcB() override; // compiler error: DerivedClass::funcB() does not
                                   // override BaseClass::funcB() const

    virtual void funcC( double = 0.0 ) override; // compiler error:
                                                 // DerivedClass::funcC(double) does not
                                                 // override BaseClass::funcC(int)

    void funcD() override; // compiler error: DerivedClass::funcD() does not
                           // override the non-virtual BaseClass::funcD()
};

Pour spécifier que les fonctions ne peuvent pas être substituées et que les classes ne peuvent pas être héritées, utilisez le mot clé final .

Voir aussi

final, spcificateur
Mots clés