Se 原始问题在底部。
我想我明白你们现在在说什么——因为成员函数指针的内部结构是编译器/机器特定的，所以我实际上不可能做到这一点。因此，即使它在我测试时有效，我也不能保证它在其他编译器/机器上也有效。
那么还有其他方法可以实现我想要的吗？
我有一个模板类和该类的基模板类，并且有一个委托类，其中包含委托类在调用时应调用的所有事件的 std::map。
我需要映射的原因是，既确保相同的成员函数（指向成员函数的事件）不会添加多次，又可以使用最初使用的对象和成员函数从映射中删除事件实例化事件对象。
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;
};
原问题：
我将函数指针存储在std::map，我正在为地图生成密钥，如下所示：std::pair<int, int>( (int)((int*)object), (int)(static_cast<const void*>(&method)) ).
method是一个函数（方法）指针，并且object是指向方法对象的指针。
它有效，但我偷偷怀疑我获取密钥第二部分的方式并不完全正确。
我从来没有完全理解函数指针，但我想我得到的是指针的地址而不是函数的地址，编译器不会让我这样做((int)(static_cast<const void*>(method))).
所以我的问题是 - 如何从函数指针获取唯一的密钥，如果我稍后从指向相同方法的另一个函数指针获取密钥，该密钥将是相同的？
提前致谢，
马丁
