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.
La parola chiave override
due scopi:
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!"); }