O que é a palavra-chave ‘override’ no C ++ usada para?

A palavra-chave override tem dois propósitos:

1. Ele mostra ao leitor do código que “este é um método virtual, que está substituindo um método virtual da class base”.
2. O compilador também sabe que é uma substituição, por isso pode “verificar” que você não está alterando / adicionando novos methods que você acha que são substituições.

Para explicar o último:

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

Em derived2 o compilador emitirá um erro para “alterar o tipo”. Sem override , no máximo, o compilador daria um aviso para “você está ocultando o método virtual pelo mesmo nome”.

e como adendo a todas as respostas, FYI: override não é uma palavra-chave , mas um tipo especial de identificador! Tem significado apenas no contexto de declarar / definir funções virtuais, em outros contextos é apenas um identificador ordinal. Para detalhes, leia 2.11.2 do Padrão .

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

Saída:

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

override é uma palavra-chave do C ++ 11 que significa que um método é uma “substituição” de um método de uma class base. Considere este exemplo:

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

Se a assinatura B::func1() não for igual à assinatura A::func1() um erro de compilation será gerado porque B::func1() não sobrescreve A::func1() , ele irá definir um novo método chamado func1() vez disso.

Wikipedia diz:

A substituição de methods, em programação orientada a objects, é um recurso de linguagem que permite que uma subclass ou class-filha forneça uma implementação específica de um método que já é fornecido por uma de suas superclasss ou classs-pai.

Em detalhe, quando você tem um object foo que tem uma function void hello ():

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

Um filho de foo, também terá uma function hello ():

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

No entanto, você pode querer imprimir “Hello Bar!” quando a function hello () está sendo chamada de um object de barra. Você pode fazer isso usando override

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