Herencia de C++ y punteros de función miembro

No estoy 100% seguro de lo que estás pidiendo, pero aquí hay un ejemplo que funciona con funciones virtuales:

#include <iostream>
using namespace std;

class A { 
public:
    virtual void foo() { cout << "A::foo\n"; }
};
class B : public A {
public:
    virtual void foo() { cout << "B::foo\n"; }
};

int main()
{
    void (A::*bar)() = &A::foo;
    (A().*bar)();
    (B().*bar)();
    return 0;
}

El problema crítico con los punteros a los miembros es que se pueden aplicar a cualquier referencia o puntero a una clase del tipo correcto. Esto significa que debido a que Z se deriva de Y, un puntero (o referencia) del tipo puntero (o referencia) a Y puede apuntar (o referirse) a la clase base sub-objeto de Z o cualquier otra clase derivada de Y.

void (Y::*p)() = &Z::z_fn; // illegal

Esto significa que cualquier cosa asignada a un puntero a miembro de Y debe funcionar realmente con cualquier Y. Si se permite señalar a un miembro de Z (que no era miembro de Y), entonces sería posible llamar a una función miembro de Z sobre algo que no era realmente un Z.

Por otro lado, cualquier puntero a miembro de Y también apunta al miembro de Z (la herencia significa que Z tiene todos los atributos y métodos de su base) es legal convertir un puntero a miembro de Y a un puntero a miembro de Z. Esto es inherentemente seguro.

void (Y::*p)() = &Y::y_fn;
void (Z::*q)() = p; // legal and safe

Es posible que desee consultar este artículo Los Punteros de Funciones Miembro y los Delegados de C++ más Rápidos Posibles La respuesta corta parece ser sí, en algunos casos.

Creo que sí. Dado que el puntero de la función usa la firma para identificarse, el comportamiento base/derivado dependería de cualquier objeto en el que lo llamaras.

Mi experimentación reveló lo siguiente: Advertencia - esto podría ser un comportamiento indefinido. Sería útil que alguien pudiera proporcionar una referencia definitiva.

1. Esto funcionó, pero requirió un cast al asignar la función miembro derivada a p.
2. Esto también funcionó, pero requirió lanzamientos adicionales al desreferenciar p.

Si nos sentimos realmente ambiciosos, podríamos preguntar si p se puede usar para apuntar a funciones miembro de clases no relacionadas. No lo intenté., pero la página FastDelegate enlazada en la respuesta de dagorym sugiere que es posible.

En conclusión, intentaré evitar usar punteros de función miembro de esta manera. Pasajes como los siguientes no inspiran confianza:

Fundición entre función miembro pointers es un área extremadamente turbia. Durante la estandarización de C++, hubo mucha discusión sobre si usted debe ser capaz de lanzar un puntero de función miembro de una clase a un miembro puntero de función de una base o clase derivada, y si usted podría lanzarse entre clases no relacionadas. En el momento en que el comité de normas tomaron una decisión, compilador diferente los proveedores ya habían hecho decisiones de ejecución encerrados en diferentes respuestas a estas preguntas. [Artículo de delegación rápida ]

Supongamos que tenemos class X, class Y : public X, and class Z : public Y

Debería ser capaz de asignar métodos para ambos X, Y a punteros de tipo void (Y::*p)() pero no métodos para Z. Para ver por qué considerar lo siguiente:

void (Y::*p)() = &Z::func; // we pretend this is legal
Y * y = new Y; // clearly legal
(y->*p)(); // okay, follows the rules, but what would this mean?

Al permitir esa asignación permitimos la invocación de un método para Z en un objeto Y que podría llevar a quién sabe qué. Puede hacer que todo funcione lanzando los punteros, pero eso no es seguro ni está garantizado para funcionar.

Aquí hay un ejemplo de lo que funciona. Puede sobrescribir un método en clase derivada, y otro método de clase base que usa puntero a este método invalidado llama de hecho al método de la clase derivada.

#include <iostream>
#include <string>

using namespace std;

class A {
public:
    virtual void traverse(string arg) {
        find(&A::visit, arg);
    }

protected:
    virtual void find(void (A::*method)(string arg),  string arg) {
        (this->*method)(arg);
    }

    virtual void visit(string arg) {
        cout << "A::visit, arg:" << arg << endl;
    }
};

class B : public A {
protected:
    virtual void visit(string arg) {
        cout << "B::visit, arg:" << arg << endl;
    }
};

int main()
{
    A a;
    B b;
    a.traverse("one");
    b.traverse("two");
    return 0;
}