Solución:
los override
palabra clave tiene dos propósitos:
- Muestra al lector del código que “este es un método virtual, que está anulando un método virtual de la clase base”.
- El compilador también sabe que es una anulación, por lo que puede “comprobar” que no está alterando / agregando nuevos métodos que cree que son anulaciones.
Para explicar esto último:
class base
{
public:
virtual int foo(float x) = 0;
};
class derived: public base
{
public:
int foo(float x) override { ... } // OK
}
class derived2: public base
{
public:
int foo(int x) override { ... } // ERROR
};
En derived2
el compilador emitirá un error para “cambiar el tipo”. Sin override
, como máximo, el compilador daría una advertencia para “estás ocultando un método virtual con el mismo nombre”.
Y como una adición a todas las respuestas, FYI: override
no es una palabra clave, pero un especial tipo de identificador! Tiene significado solo en el contexto de declarar / definir funciones virtuales, en otros contextos es solo un ordinario identificador. Para obtener más detalles, lea 2.11.2 de El estandar.
#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;
}
Producción:
[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
es una palabra clave de C ++ 11, lo que significa que un método es una “anulación” de un método de una clase base. Considere este ejemplo:
class Foo
{
public:
virtual void func1();
}
class Bar : public Foo
{
public:
void func1() override;
}
Si B::func1()
la firma no es igual A::func1()
firma se generará un error de compilación porque B::func1()
no anula A::func1()
, definirá un nuevo método llamado func1()
en lugar de.