Sobreescritura vs Virtual

Si la función fuera virtual, entonces podría hacer esto y aún así obtener la salida"2":

Parent* a = new Child();
a->say();

Esto funciona porque una función virtual usa el tipo actual mientras que una función no virtual usa el tipo declarado. Lea sobrepolimorfismo para una mejor discusión de por qué querría hacer esto.

Pruébalo con:

Parent *a = new Child();
Parent *b = new Parent();

a->say();
b->say();

Sin virtual, ambos con la letra "1". Agregue virtual, y el niño actuará como un Niño, a pesar de que se le hace referencia a través de un puntero a Parent.

Si no utiliza la palabra clave virtual no está sobreescribiendo, sino que rahter define un método no relacionado en la clase derivada que ocultará el método de la clase base. Es decir, sin la virtual, Base::say y Derived::say no están relacionados besides además de la coincidencia de nombre.

Cuando utiliza la palabra clave virtual (requerida en la base, opcional en la clase derivada), le está diciendo al compilador que las clases que derivan de esta base podrán anular el método. En ese caso, Base::say y Derived::say se consideran sobreescrituras del mismo método.

Cuando se usa una referencia o puntero a una clase base para llamar a un método virtual, el compilador agregará el código apropiado para que se llame al overrider final (el override en la clase más derivada que define el método en la jerarquía de la instancia concreta en uso). Tenga en cuenta que si no usa referencias / puntero sino variables locales, el compilador puede resolver la llamada y no necesita usar el despacho virtual mecanismo.

Bueno, lo probé por mí mismo, porque hay muchas cosas en las que podemos pensar:

#include <iostream>
using namespace std;
class A
{
public:
    virtual void v() { cout << "A virtual" << endl; }
    void f() { cout << "A plain" << endl; }
};

class B : public A
{
public:
    virtual void v() { cout << "B virtual" << endl; }
    void f() { cout << "B plain" << endl; }
};

class C : public B
{
public:
    virtual void v() { cout << "C virtual" << endl; }
    void f() { cout << "C plain" << endl; }
};

int main()
{
    A * a = new C;
    a->f();
    a->v();

    ((B*)a)->f();
    ((B*)a)->v();
}

Salida:

A plain
C virtual
B plain
C virtual

Creo que una respuesta buena, simple y corta podría verse así (porque creo que las personas que pueden entender más pueden memorizar menos, por lo tanto, necesitan una explicación corta y simple):

Los métodos virtuales comprueban los DATOS de la instancia a la que apunta el puntero, mientras que los métodos clásicos no llaman al método que corresponde al especificado tipo.

El punto de esa característica es el siguiente: supongamos que tiene una matriz de A. La matriz puede contener B, C, (o incluso tipos derivados. ). si desea llamar secuencialmente al mismo método de todas esas instancias, llamaría a cada una que sobrecargó.

Encuentro esto bastante difícil de entender, y obviamente cualquier curso de C++ debería explicar cómo se logra esto, porque la mayoría de las veces solo se te enseña sobre funciones virtuales, las usas, pero hasta que entiendes cómo el compilador los entiende y cómo el ejecutable manejará las llamadas, usted está en la oscuridad.

Lo que pasa con VFtables es que nunca me han explicado qué tipo de código agrega, y eso es obviamente aquí donde C++ requiere mucha más experiencia que C, y esta podría ser la razón principal por la que C++ fue etiquetado como "lento" en sus primeros días: de hecho, es poderoso, pero como todo, es poderoso si sabes cómo usarlo, o simplemente "te vuelas toda la pierna".

Cuando se utiliza la palabra clave virtual, se crea una tabla de funciones virtuales para localizar los métodos correctos en una instancia. Entonces, incluso si la instancia derivada es apuntada por un puntero de clase base, todavía encontrará la implementación correcta del método.

Este es un aspecto muy importante de la programación en c++ almost casi todas las entrevistas a las que he ido, me hacen esta pregunta.

¿Qué sucede si cambia su main a:

int main() { Parent* a = new Child(); a->say(); return 0; }

También, vale la pena entender lo que es un vtable.