Puntero de C++ a la función virtual

Si tienes una estructura como esta

struct A {
    void func();
};

y una referencia como esta

A& a;

puede obtener un puntero a su func método como este:

someMethod(&A::func);

Ahora, ¿qué sucede si ese método es virtual y no sabe qué es en tiempo de ejecución? ¿Por qué no puedes obtener un puntero como este?

someMethod(&a.func);

¿Es posible obtener un puntero a ese método?

Los punteros a miembros tienen en cuenta la virtualidad de las funciones a las que apuntan. Por ejemplo:

#include <iostream>
struct Base
{
    virtual void f() { std::cout << "Base::f()" << std::endl; }
};

struct Derived:Base
{
    virtual void f() { std::cout << "Derived::f()" << std::endl; }
};


void SomeMethod(Base& object, void (Base::*ptr)())
{
    (object.*ptr)();    
}


int main()
{
    Base b;
    Derived d;
    Base* p = &b;
    SomeMethod(*p, &Base::f); //calls Base::f()
    p = &d;
    SomeMethod(*p, &Base::f); //calls Derived::f()    
}

Salidas:

Base::f()
Derived::f()

La forma de invocar un puntero de función es proporcionar también el puntero de instancia de su objeto. Esto se encargará de todos los problemas de virtualidad:

struct A { void func(); };

int main()
{
  typedef void (A::*mf)();

  A x; // irrelevant if A is derived or if func is virtual

  mf f = &A::func;   // pointer-to-member-function
  A* p = &x;         // pointer-to-instance

  (p->*f)();           // invoke via pointer
  (x.*f)();            // invoke directly
}

bien, interesante desafío de sintaxis pregunta: Supongamos que tengo esto.

struct Basil { virtual void foo(); virtual ~Basil(); };
struct Derrek : public Basil { virtual void foo(); };

Ahora si tengo Derrek * p o un Basil * ppuedo invocar el Basil miembro a través de p->Basil::foo(). ¿Cómo podría hacer lo mismo si me dieran un void(Derrek::*q)() = &Derrek::foo?

Responder: No se puede hacer. el PMF q alone no sabe si apunta a una función virtual, y mucho menos a cuál, y no se puede usar para buscar una función de clase base en tiempo de ejecución. [Thanks to Steve and Luc!]

Puede obtener un puntero hacia él, así:

struct A {
    virtual void foo() = 0;
};

typedef void (A::*LPFOO)();

LPFOO pFoo = &A::foo;