A cosa serve la parola chiave ‘override’ in C ++?

La parola chiave override due scopi:

1. Mostra al lettore del codice che “questo è un metodo virtuale, che sovrascrive un metodo virtuale della class base”.
2. Il compilatore sa anche che è un override, quindi può “controllare” che non stai modificando / aggiungendo nuovi metodi che pensi siano sovrascritti.

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

In 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”.

e come addendum a tutte le risposte, FYI: override non è una parola chiave , ma un tipo speciale di identificatore! Ha significato solo nel contesto della dichiarazione / definizione di funzioni virtuali, in altri contesti è solo un identificatore ordinale. Per i dettagli leggi 2.11.2 di The Standard .

 // kate: hl C++11; #include  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; } 

Produzione:

 [email protected] /work/tests $ g++ -std=c++11 -o override-test override-test.cc [email protected] /work/tests $ ./override-test virtual void derived::foo() 

override è una parola chiave C ++ 11 che significa che un metodo è un “override” da un metodo di una class base. Considera questo esempio:

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

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

Wikipedia dice:

Il metodo che sovrascrive, nella programmazione orientata agli oggetti, è una funzionalità linguistica che consente a una sottoclass o class figlia di fornire un’implementazione specifica di un metodo che è già fornito da una delle sue superclassi o classi parent.

In dettaglio, quando hai un object foo che ha una funzione void hello ():

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

A child of foo, avrà anche una funzione hello ():

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

Tuttavia, potresti voler stampare “Hello Bar!” quando la funzione hello () viene chiamata da un object bar. Puoi farlo usando l’override

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