¿De dónde vienen los bloqueos de la "llamada de función virtual pura"?

Question

A veces veo programas que se cuelgan en mi computadora con el error: "llamada de función virtual pura".

¿Cómo se compilan estos programas cuando no se puede crear un objeto de una clase abstracta?

Answer 1

Se pueden producir si intenta realizar una llamada de función virtual desde un constructor o un destructor. Como no puede realizar una llamada de función virtual desde un constructor o destructor (el objeto de clase derivado no se ha construido o ya se ha destruido), llama a la versión de clase base, que en el caso de una función virtual pura, doesn existo

(Ver demostración en vivo here)

class Base 
{ 
public: 
    Base() { doIt(); } // DON'T DO THIS 
    virtual void doIt() = 0; 
}; 

void Base::doIt() 
{ 
    std::cout<<"Is it fine to call pure virtual function from constructor?"; 
} 

class Derived : public Base 
{ 
    void doIt() {} 
}; 

int main(void) 
{ 
    Derived d; // This will cause "pure virtual function call" error 
} 

Answer 2

Supongo que hay un vtbl creado para la clase abstracta por algún motivo interno (puede ser necesario para algún tipo de información de tipo de tiempo de ejecución) y algo sale mal y un objeto real lo recibe. Es un error. Solo eso debería decir que algo que no puede suceder es.

Pura especulación

edición: Parece que estoy mal en el caso de que se trate. OTOH IIRC algunos lenguajes permiten llamadas vtbl desde el constructor destructor.

Answer 3

lo general, cuando se llama a una función virtual a través de una referencia colgante - más probable es que la instancia ya ha sido destruida.

También puede haber más razones "creativas": tal vez ha logrado cortar la parte de su objeto donde se implementó la función virtual. Pero generalmente es solo que la instancia ya ha sido destruida.

Answer 4

Aquí hay una manera furtiva de que suceda. Esto me pasó esencialmente hoy.

class A 
{ 
    A *pThis; 
    public: 
    A() 
    : pThis(this) 
    { 
    } 

    void callFoo() 
    { 
    pThis->foo(); // call through the pThis ptr which was initialized in the constructor 
    } 

    virtual void foo() = 0; 
}; 

class B : public A 
{ 
public: 
    virtual void foo() 
    { 
    } 
}; 

B b(); 
b.callFoo(); 

Answer 5

Al igual que el caso estándar de llamar a una función virtual desde el constructor o destructor de un objeto con funciones virtuales puras también se puede obtener una llamada de función virtual pura (en MSVC al menos) si se llama a un Portal función después de que el objeto ha sido destruido. Obviamente, esto es bastante malo intentarlo, pero si trabajas con clases abstractas como interfaces y te equivocas, entonces es algo que podrías ver. Posiblemente sea más probable si está usando interfaces contadas de referencia y tiene un error de recuento de ref o si tiene una condición de carrera de uso de objeto/destrucción de objeto en un programa de subprocesos múltiples ... Lo que pasa con estos tipos de llamadas puros es que es a menudo es menos fácil comprender lo que está sucediendo, ya que un cheque para los "sospechosos habituales" de llamadas virtuales en Ctor y Dtor saldrá limpio.

Para ayudar a depurar este tipo de problemas, puede, en diversas versiones de MSVC, reemplazar el controlador purecall de la biblioteca en tiempo de ejecución. Para ello, debe proporcionar su propia función con esta firma:

int __cdecl _purecall(void) 

y vincularla antes de vincular la biblioteca de tiempo de ejecución. Esto le da a USTED control de lo que ocurre cuando se detecta una llamada pura. Una vez que tenga el control, puede hacer algo más útil que el controlador estándar. Tengo un controlador que puede proporcionar un rastro de pila de donde ocurrió el llamado puro; mira aquí: http://www.lenholgate.com/blog/2006/01/purecall.html para más detalles.

(Tenga en cuenta que también puede llamar a _set_purecall_handler() para instalar su controlador en algunas versiones de MSVC).

Answer 6

Uso VS2010 y cada vez que intento llamar al destructor directamente desde el método público, aparece un error de "llamada de función virtual pura" durante el tiempo de ejecución.

template <typename T> 
class Foo { 
public: 
    Foo<T>() {}; 
    ~Foo<T>() {}; 

public: 
    void SomeMethod1() { this->~Foo(); }; /* ERROR */ 
}; 

Así que se trasladó lo que hay dentro ~ Foo() para separar método privado, entonces funcionó a las mil maravillas.

template <typename T> 
class Foo { 
public: 
    Foo<T>() {}; 
    ~Foo<T>() {}; 

public: 
    void _MethodThatDestructs() {}; 
    void SomeMethod1() { this->_MethodThatDestructs(); }; /* OK */ 
};