Llamar a una función virtual estáticamente a través de un puntero a la función

Question

Considere el siguiente código.

#include <iostream> 
#include <memory> 

struct A { 
    A() {} 
    virtual void f() { 
    std::cout << "A::f" << std::endl; 
    } 
private: 
    A(const A&); 
}; 

struct B : public A { 
    virtual void f() { 
    std::cout << "B::f" << std::endl; 
    call(&A::f); 
    } 
private: 
    void call(void (A::*aMethod)()) { 
    // ... 
    (static_cast<A&>(*this).*aMethod)(); 
    //(static_cast<A>(*this).*aMethod)(); -> not allowed to copy! 
    // ... 
    } 
}; 

void main() { 
    std::auto_ptr<B> b (new B); 
    b->f(); 
} 

Este código llama de forma recursiva el mismo método B::f hasta que se agote la pila, mientras que me gustaría que el método call llamar A::f. Es decir, se debe llamar de forma estática, ya que normalmente pasaría si hubiera escrito simplemente:

struct B : public A { 
    virtual void f() { 
    std::cout << "B::f" << std::endl; 
    // ... 
    A::f(); 
    // ... 
    } 
}; 

La razón por la que quieren tener el método call es factorizar algún código antes y después de la 'llamada estática' que es común a varios métodos con la misma firma como f ...

¿Cómo puedo estáticamente llamar a una función virtual decidió en tiempo de ejecución?

Answer 1

que se espera. La expresión del objeto es una Referencia a la clase Base A y, por lo tanto, el mecanismo de función virtual (vinculación dinámica) se activa cuando A :: f es virtual.

Sólo el operador puede supperess :: mecanismo de llamada a una función virtual.

$ 10,3/12- "calificación explícita con el operador alcance (5.1) suprime el mecanismo de llamada virtual."

Answer 2

Su anulación se resuelve cuando toma el puntero, por lo que lo que desea aquí no es posible de esta manera. Lo mejor que puede hacer es un contenedor que llame a su función, ya sea algo externo o una función no virtual que llame a su función. Si tiene características de C++ 0x, podría usar una lambda que es la solución más limpia de la OMI.

Es posible que desee replantearse la forma en que realiza las funciones previas/posteriores como otra forma de abordar su problema: pueden implementarse sobrecargando el operador "->".