O que é a palavra-chave 'override' em C++ usada para?




virtual function c++ (4)

Eu sou um iniciante em C ++. Eu vi a palavra-chave override usada no arquivo de cabeçalho no qual estou trabalhando. Posso saber, qual é o uso real da override , talvez com um exemplo seria fácil de entender.


override é uma palavra-chave do C ++ 11 que significa que um método é uma "substituição" de um método de uma classe 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 compilação será gerado porque B::func1() não sobrescreve A::func1() , irá definir um novo método chamado func1() vez disso.


A palavra-chave override tem dois propósitos:

  1. Ele mostra ao leitor do código que "este é um método virtual, que está sobrescrevendo um método virtual da classe base".
  2. O compilador também sabe que é uma substituição, portanto, pode "verificar" que você não está alterando / adicionando novos métodos que você acha que são substituídos.

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

Saída:

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

Wikipedia diz:

A substituição de métodos, em programação orientada a objetos, é um recurso de linguagem que permite que uma subclasse ou classe filha forneça uma implementação específica de um método que já é fornecido por uma de suas superclasses ou classes pai.

Em detalhe, quando você tem um objeto foo que tem uma função void hello ():

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

Um filho de foo, também terá uma função 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 função hello () está sendo chamada de um objeto de barra. Você pode fazer isso usando override

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




method-overriding