override specifier (since C++11)

Especifica que una función virtual sobrescribe otra función virtual.

Sintaxis

El identificador override , si se utiliza, aparece inmediatamente después del declarador en la sintaxis de una declaración de función miembro o una definición de función miembro dentro de una definición de clase.

En ambos casos, virt-specifier-seq , si se utiliza, es ya sea override o final , o final override o override final .

Explicación

En una declaración o definición de función miembro, override asegura que la función es virtual y está sobrescribiendo una función virtual de una clase base. El programa está mal formado (se genera un error en tiempo de compilación) si esto no es cierto.

override es un identificador con un significado especial cuando se utiliza después de declaradores de funciones miembro; no es una palabra clave reservada en otros casos.

Palabras clave

override

Ejemplo

#include <iostream>
struct A
{
    virtual void foo();
    void bar();
    virtual ~A();
};
// definiciones de funciones miembro de la estructura A:
void A::foo() { std::cout << "A::foo();\n"; }
A::~A() { std::cout << "A::~A();\n"; }
struct B : A
{
//  void foo() const override; // Error: B::foo no sobreescribe A::foo
                               // (incompatibilidad de firma)
    void foo() override; // OK: B::foo sobreescribe A::foo
//  void bar() override; // Error: A::bar no es virtual
    ~B() override; // OK: `override` también puede aplicarse a funciones
                   // miembro especiales virtuales, ej. destructores
    void override(); // OK, nombre de función miembro, no palabra clave reservada
};
// definiciones de funciones miembro de la estructura B:
void B::foo() { std::cout << "B::foo();\n"; }
B::~B() { std::cout << "B::~B();\n"; }
void B::override() { std::cout << "B::override();\n"; }
int main()
{
    B b;
    b.foo();
    b.override(); // OK, invoca la función miembro `override()`
    int override{42}; // OK, define una variable entera
    std::cout << "override: " << override << '\n';
}

B::foo();
B::override();
override: 42
B::~B();
A::~A();

Véase también