Se pregunta original en el fondo.

Creo que entiendo lo que ustedes están diciendo ahora, que debido a que la estructura interna del puntero a la función miembro es específica del compilador / máquina, realmente no es posible hacer lo que estoy intentando. Entonces, aunque funcione cuando lo pruebo, no tengo ninguna garantía de que lo haga en otros compiladores / máquinas.

¿Hay otra manera de hacer lo que quiero entonces?

Tengo una clase de plantilla y una clase de plantilla base para esa clase, y tengo una clase delegada que contiene un std :: map de todos los eventos que la clase delegada debe invocar, cuando se invoca.

La razón por la que necesito un mapa es, tanto para asegurar que la misma función miembro (evento que apunta a la función miembro) no se agregue más de una vez, y para hacer posible eliminar eventos del mapa utilizando el objeto y la función miembro originalmente utilizados cuando instanciar el objeto de evento.

template <class T_arg1> struct EventBase1
{
public:
    bool operator < (const EventBase1 &event1) const { return _key < event1._key; };
    virtual void operator()(T_arg1 t1) const {};
    std::pair<intptr_t, intptr_t> _key;
};

template <class T, class T_arg1> struct Event1: public EventBase1<T_arg1>
{
    template <class T_arg1> friend class Delegate1;
    typedef typename void (T::*Method)(T_arg1);
private:
    Method _method;
    T* _object;
public:
    Event1(T* object, Method method): _object(object), _method(method)
    {
        _key = std::pair<intptr_t, intptr_t>(reinterpret_cast<intptr_t>(object), reinterpret_cast<intptr_t>( reinterpret_cast<void*&>(method)));
    };
    virtual void operator()(T_arg1 t1) const {
        (_object->*_method)(t1);
    };
};

template <class T_arg1> class Delegate1
{
public:
    typedef typename EventBase1<T_arg1> T_event;
    void operator += (T_event* observer)
    {
        assert(observer);
        _observers[*observer] = observer;
    };
    void operator -= (const T_event &observer)
    {
        std::map<T_event, T_event*>::iterator i = _observers.find(observer);
        if(i != _observers.end()) {
            delete i->second;
            _observers.erase(i);
        }
    };
    void operator()(T_arg1 t1)
    {
        for(std::map<T_event, T_event*>::iterator i = _observers.begin(); i != _observers.end(); i++) {
            (*(i->second))(t1);
        }
    };
private:
    std::map<T_event, T_event*> _observers;     
};

Pregunta original:

Estoy almacenando punteros de función en unstd::map, y estoy generando mi clave para el mapa de la siguiente manera:std::pair<int, int>( (int)((int*)object), (int)(static_cast<const void*>(&method)) ).

method es un puntero de función (método), yobject Es un puntero al objeto del método.

Funciona, sin embargo, tengo la sospecha de que la forma en que obtengo la segunda parte de la clave no es del todo correcta.

Nunca he entendido completamente los punteros de función, pero creo que estoy obteniendo la dirección del puntero y no la dirección de la función, y el compilador no me deja hacer esto((int)(static_cast<const void*>(method))).

Entonces, mi pregunta es: ¿cómo obtengo una clave única del puntero de función que será igual si luego obtengo la clave de otro puntero de función que apunta con el mismo método?

Gracias de antemano, Martin