Cómo implementar la función virtual pura en C++

Question

Creo que la implementación de la función virtual se habla mucho. Mi pregunta es ¿qué hay de la función virtual pura? Sin embargo, se implementa? En la tabla virtual, ¿cómo decirlo es puro o no puro? ¿Cuál es la diferencia entre la función virtual pura y la función virtual con la implementación?

Answer 1

Normalmente no hay diferencia de implementación entre las funciones virtuales puras y no puras. Siempre que se defina una función puramente virtual, actúa como cualquier otra función virtual. Si no está definido, solo causa un problema si se llama explícitamente.

Existen dos grandes diferencias en el comportamiento, pero generalmente no hay impacto en la implementación del mecanismo de función virtual en sí. El compilador no debe permitirle construir un objeto de un tipo que tenga funciones virtuales puras que no tengan una anulación final no pura en su jerarquía de herencia y cualquier intento de realizar una llamada virtual a una función virtual pura, directa o indirectamente desde el constructor o destructor de un objeto causa un comportamiento indefinido.

Answer 2

No sé la implementación real, pero una buena opción sería implementarla como un puntero NULL en el vtable. En otras palabras, si tiene una implementación, hay un puntero de función válido en vtable y si es puramente virtual, tiene un puntero NULL.

Esto es tan lógico que incluso creo que es implementado de esta manera :-).

Answer 3

virtual void foo() = 0;

Una función virtual pura sigue siendo una función virtual, por lo que estaría en el vtable, pero el compilador no requiere una implementación para él, y prohibirá la creación de instancias de la clase base que declara el virtual puro. Como todavía puede desreferenciar los punteros de tipo de la clase base abstracta, la tabla virtual debe tener una entrada para el polimorfismo y el enlace de tiempo de ejecución.

¿Eso ayuda?

Answer 4

Esta no es una respuesta, sino más bien una continuación de los comentarios a this answer above

El lenguaje C++ define cómo funciona el mecanismo de despacho virtual se lleva a cabo durante la construcción. Al crear instancias de un objeto en una jerarquía, se llama al constructor base (*). En ese punto, el mecanismo de despacho virtual se inicializa para la clase base. En esta etapa, las funciones virtuales se enviarán a la implementación base. Cualquier llamada a un método virtual no puro que utilice el mecanismo de despacho virtual (sin calificación explícita de clase) llamará a la implementación base.

Después de que se complete el constructor base, el mecanismo de expedición virtual (por lo general vtable) se reseted a la versión tipo derivado, y cualquier llamada dinámica a partir de ahí se llame a la versión derivada de los métodos:

struct base { 
    virtual void non_pure() { std::cout << "base::non_pure" << std::endl; } 
    virtual void pure_not_implemented() = 0; 
    virtual void pure_implemented() = 0; 

    base() {      // at this point the object is a ´base´ 
     non_pure();    // base::non_pure 
     // pure_not_implemented(); // runtime error: pure virtual method called 
     pure_implemented();  // base::pure_implemented 
     // base::pure_not_implemented(); // link error 
    } 
}; 
void base::pure_implemented() { std::cout << "base::pure_implemented" << std::endl; } 
struct derived : base { 
    virtual void non_pure() { std::cout << "derived::non_pure" << std::endl; } 
    virtual void pure_not_implemented() { std::cout << "derived::pure_not_implemented" << std::endl; } 
    virtual void pure_implemented() { std::cout << "derived::pure_implemented" << std::endl; 

    derived() {    // after the implicit call to the base class 
           // this is a ´derived´ object, now calls will 
           // get dispatched to derived:: implementations 
     non_pure();    // derived::non_pure 
     pure_not_implemented(); // derived::pure_not_implemented 
     pure_implemented();  // derived::pure_implemented 
     base::non_pure();  // base::non_pure 
     // base::pure_not_implemented() // link error 
    } 
}; 

Tenga en cuenta que existen diferencias entre utilizar el mecanismo de despacho dinámico (generalmente, vtable) y llamar a un método específico con el nombre completo. Se permitirá una llamada a un método virtual puro no implementado a través de la calificación completa en tiempo de compilación, pero fallará en el momento del enlace (el vinculador no puede encontrar una implementación para llamar).

Esta es una decisión importante en el diseño del idioma. La otra opción (la que tomó Java) es inicializar el mecanismo de despacho virtual al tipo más derivado desde el principio, antes de llamar al constructor de la clase base.El problema que tiene este enfoque es que si el constructor base llama a un método virtual (que en Java son todos) se enviará a la implementación más derivada y se ejecutará en un objeto aún no construido, posiblemente causando resultados inesperados:

public class Base 
{ 
    public Base() { 
     f(); 
    } 
    public void f() { 
     System.out.println("Base.f"); 
    } 
} 
public class Derived extends Base { 
    public final int constant; 
    public Derived() { constant = 5; } 
    public void f() { 
     System.out.println("Derived.f() " + constant); 
    } 
    public static void main(String args[]) { 
     Derived d = new Derived(); // prints Derived.f() 0 
    } 
} 

En la versión de Java, el mecanismo de envío dinámico considera que el objeto es del tipo Derived desde el principio. La llamada al f() en el constructor base se enviará dinámicamente a la implementación derivada. En el ejemplo anterior, incluso si la variable se declara como final y por lo tanto una constante por el valor de 5 (parece obvio en el código), el valor impreso real es 0 porque el constructor de Derived no se ha ejecutado.

(*) Esto es demasiado simplista, pero los detalles en realidad no afectan el argumento.