Identificatore override

È possibile usare la parola chiave override per designare le funzioni membro che eseguono l'override di una funzione virtuale in una classe di base.

Sintassi

function-declaration override;

Osservazioni:

override è sensibile al contesto e ha un significato speciale solo quando viene usato dopo una dichiarazione di funzione membro; in caso contrario, non è una parola chiave riservata.

Esempio

Usare l'override per impedire il comportamento di ereditarietà accidentale nel codice. Nell'esempio seguente viene illustrato dove, senza usare override, il comportamento della funzione membro della classe derivata potrebbe non essere stato previsto. Il compilatore non genera alcun errore per questo codice.

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
};

Quando si usa l'override, il compilatore genera errori anziché creare automaticamente nuove funzioni membro.

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()
};

Per specificare che le funzioni non possono essere sottoposte a override e che le classi non possono essere ereditate, usare la parola chiave finale .

Vedi anche

Identificatore final
Parole chiave