Per che cosa si usa la parola chiave 'override' in C++?

Question

Sono un principiante in C++. Ho trovato la parola chiave override utilizzata nel file di intestazione su cui sto lavorando. Posso sapere, che cosa è l'uso reale di override, forse con un esempio sarebbe facile da capire.

Answer 1

Il override parola chiave serve a due scopi:

1. mostra al lettore del codice che "questo è un metodo virtuale, che è prevalente un metodo virtuale della classe di base."
2. Il compilatore sa anche che è un override, quindi può "verificare" che non si stiano modificando/aggiungendo nuovi metodi che si ritiene siano prioritari.

Per spiegare quest'ultimo:

class base 
{ 
    public: 
    virtual int foo(float x) = 0; 
}; 


class derived: public base 
{ 
    public: 
    int foo(float x) override { ... do stuff with x and such ... } 
} 

class derived2: public base 
{ 
    public: 
    int foo(int x) override { ... } 
}; 

Nel derived2 il compilatore emetterà un errore per "cambiare il tipo". Senza override, al massimo il compilatore darebbe un avvertimento per "stai nascondendo il metodo virtuale con lo stesso nome".

Answer 2

override è una parola chiave C++ 11 che significa che un metodo è un "override" da un metodo di una classe base. Considerate questo esempio:

class Foo 
    { 
    public: 
     virtual void func1(); 
    } 

    class Bar : public Foo 
    { 
    public: 
     void func1() override; 
    } 

Se B :: FUNC1() firma non è uguale a firma A :: FUNC1() un errore di compilazione verrà generato perché B :: FUNC1() non sovrascrive A :: func1(), definirà invece un nuovo metodo chiamato func1().

Answer 3

Wikipedia dice:

Metodo di primaria importanza, in programmazione orientata agli oggetti, è una caratteristica del linguaggio che permette una classe sottoclasse o un bambino per fornire una specifica implementazione di un metodo che viene già fornita da una delle sue superclassi o classi genitore.

In dettaglio, quando si ha un foo oggetto che ha un vuoto ciao) Funzione (:

class foo { 
    virtual void hello(); // Code : printf("Hello!"); 
} 

Un bambino di foo, avrà anche una) funzione ciao (:

class bar : foo { 
    // no functions in here but yet, you can call 
    // bar.hello() 
} 

Tuttavia, è possibile stampare "Hello Bar!" quando la funzione hello() viene chiamata da un oggetto bar. È possibile farlo utilizzando esclusione

class bar : foo { 
    virtual void hello() override; // Code : printf("Hello Bar!"); 
} 

Answer 4

e come addendum a tutti risponde, FYI: overridenon è una parola chiave, ma un speciale tipo di identificatore! Ha significato solo nel contesto della dichiarazione/definizione delle funzioni virtuali, in altri contesti è solo un identificatore ordinario . Per dettagli vedi 2.11.2 di Standard.

// kate: hl C++11; 
#include <iostream> 

struct base 
{ 
    virtual void foo() = 0; 
}; 

struct derived : base 
{ 
    virtual void foo() override 
    { 
     std::cout << __PRETTY_FUNCTION__ << std::endl; 
    } 
}; 

int main() 
{ 
    base* override = new derived(); 
    override->foo(); 
    return 0; 
} 

uscita:

zaufi@gentop /work/tests $ g++ -std=c++11 -o override-test override-test.cc 
zaufi@gentop /work/tests $ ./override-test 
virtual void derived::foo()