¿Qué significa la palabra clave virtual al anular un método?

Question

¿Qué significa la palabra clave virtual al anular un método? No lo estoy usando y todo funciona bien.

¿Todos los compiladores se comportan igual en este sentido?

¿Debo usarlo o no?

Answer 1

No se puede reemplazar una función miembro sin ella.

Sólo puede ocultar uno.

struct Base { 
    void foo() {} 
}; 

struct Derived : Base { 
    void foo() {} 
}; 

Derived::foo hace no override Base::foo; simplemente esconde porque tiene el mismo nombre, de modo que la siguiente:

Derived d; 
d.foo(); 

invoca Derived::foo.

virtual permite polimorfismo tal que en realidad o funciones de mando:

struct Base { 
    virtual void foo() {} 
}; 

struct Derived : Base { 
    virtual void foo() {} // * second `virtual` is optional, but clearest 
}; 

Derived d; 
Base& b = d; 
b.foo(); 

Esto invoca Derived::foo, porque esto ahora anulacionesBase::foo — su objeto es polimórfico.

(También tiene de usar referencias o punteros para esto, debido a the slicing problem.)

---

• Derived::foo no tiene que repetir la palabra clave virtual porque Base::foo ya se ha utilizado. Esto está garantizado por el estándar y puede confiar en él. Sin embargo, algunos piensan que es mejor mantener eso para mayor claridad.

Answer 2

Un método virtual en la clase base se aplicará en cascada a través de la jerarquía, haciendo que cada método de subclase con la misma firma también virtual.

class Base{ 
public: 
    virtual void foo(){} 
}; 

class Derived1 : public Base{ 
public: 
    virtual void foo(){} // fine, but 'virtual' is no needed 
}; 

class Derived2 : public Base{ 
public: 
    void foo(){} // also fine, implicitly 'virtual' 
}; 

le recomiendo escribir la virtual sin embargo, si a modo de documentación solamente.

Answer 3

Cuando una función es virtual, permanece virtual en toda la jerarquía, especifique o no explícitamente cada vez que sea virtual. Al reemplazar un método, utilice virtuales con el fin de ser más explícitos - ninguna otra diferencia :)

class A 
{ 
    virtual void f() 
    { 
     /*...*/ 
    }; 
}; 

class B:public A; 
{ 
    virtual void f() //same as just void f() 
    { 
     /*...*/ 
    }; 
};