How can I hash (std::hash or boost::hash) a C++ pointer-to-member-function?
Example:
I have several bool (Class::*)() pointers that point to several different methods of the class Class and I need to hash those pointers-to-member-function.
How can I do that?
Also how can I compare (std::less) those member function pointers so I can store them in an std::set?
All C++ objects, including pointers to member functions, are represented in memory as an array of chars. So you could try:
bool (Class::*fn_ptr)() = &Class::whatever; const char *ptrptr = static_cast<const char*>(static_cast<const void*>(&fn_ptr)); Now treat ptrptr as pointing to an array of (sizeof(bool (Class::*)())) bytes, and hash or compare those bytes. You can use unsigned char instead of char if you prefer.
This guarantees no false positives - in C++03, pointers to member functions are POD, which means among other things that they can be copied using memcpy. This implies that if have the same byte-for-byte values, then they are the same.
The problem is that the storage representation of member function pointers could include bits which do not participate in the value - so they will not necessarily be the same for different pointers to the same member function. Or the compiler might, for some obscure reason, have more than one way of pointing to the same function of the same class, which are not byte-wise equal. Either way you can get false negatives. You'll have to look into how member function pointers actually work on your implementation. It must implement operator== for member function pointers somehow, and if you can find out how then you can probably figure out an order and a hash function.
That's potentially hard: member function pointers are awkward, and the storage is likely to include different amounts of non-participating "slack space" according to what kind of function is pointed to (virtual, inherited). So you'll probably have to interact quite significantly with your compiler's implementation details. This article might help get you started: http://www.codeproject.com/KB/cpp/FastDelegate.aspx
A cleaner alternative might be to do a linear search through an array in order to "canonicalise" all your function pointers, then compare and hash based on the position of the "canonical" instance of that function pointer in your array. Depends what your performance requirements are. And even if there are requirements, does the class (and its derived classes) have so many functions that the linear search will take that long?
using func = bool (Class::*)(); vector<func> canon; size_t getIndexOf(func fn_ptr) { vector<func>::iterator it = find(canon.begin(), canon.end(), fn_ptr); if (it != canon.end()) return it - canon.begin(); canon.push_back(func); return canon.size() - 1; } 
I could not cast the pointer (in Microsoft compiler 2010)as described in previous answer but this works for me:
static string fmptostr(int atype::*opt) { char buf[sizeof(opt)]; memcpy(&buf,&opt,sizeof(opt)); return string(buf,sizeof(opt)); } About bitwise identity of the pointer, it can be bitwise so it seems if appropriate compiler switches are used. At least this is true for Microsoft compiler E.g using #pragma pointers_to_members and a switch.../vmg
If your member function pointer is unique, which is true in most of cases for callback-based subscriptions, then you can use the tick with type_index, which uniqueness is guaranteed by uniqueness of type (i.e. Class::Method) in your program, and it is suitable to be stored in unordered_map, i.e.
struct MyEvent { using fn_t = std::function<void(MyEvent &)>; using map_t = std::unordered_map<std::type_index, fn_t>; template <typename Handler> void subscribe(Object& obj, Handler&& handler) { fn_t fn = [&, handler = std::move(handler)](MyEvent& event) { (obj.*handler)(event); } std::type_index index = typeid(Handler); subscribers.emplace(std::move(index), std::move(fn)); } void fire() { for(auto& pair: subscribers) { auto& fn = pair.second; fn(*this); } } map_t subscribers; } And the subscription and fire event example:
MyEvent event; MyObject obj = ...; event.subscribe(obj, &MyObject::on_event ); ... event.fire(); So, example above gives you class/method uniqueness, and if you need object/method uniqueness, then you should have an struct, which provides combined hash, assuming that there is std::hash<MyObject> and there is already std::hash<std::type_index> for a member function pointer.
