Comparing pointers to member functions - c++

Question

I want to store a pointer to member function in some kind of object. Later in the programm i want to compare it to another one.
Requirenment is that the type of object that holds first pointer must be concrete (i need to store them in one container)
I failed to apply Type-erasure here because template functions can not be virtual, so i can not provide an interface "compareWith" to be overridden.
There is a half-working solution i came up with, but the problem here is with the types of Fnc objects - those are different and can not be stored in the same container. I do need to store them in the same container.
Simplified version is below:
template<class T>
class Fnc
{
public:
Fnc(T&& fnc) : m_fnc(std::forward<T>(fnc)) {}
template<class Y>
bool compareWith(const Fnc<Y>& other) {
return other.m_fnc == m_fnc;
}
private:
T m_fnc;
};
class MyClass
{
public:
void method1(int a);
void method2(int a);
void method3();
}
int main() {
//This block obviously works because i didnt try to put Fnc-objects to container
Fnc fnc1(&MyClass::method1);
Fnc fnc2(&MyClass::method2);
printf("%d\n", fnc1.compareWith(Fnc(&MyClass::method1))); //prints "1"
printf("%d\n", fnc1.compareWith(Fnc(&MyClass::method3))); //prints "0"
printf("%d\n", fnc2.compareWith(Fnc(&MyClass::method2))); //prints "1"
//This block is not working because Fnc is not polymorphic(and cannot be - template functions can not be virtual)
std::vecotor<Fnc> methods;
methods.push_back(Fnc(&MyClass::method1));
methods.push_back(Fnc(&MyClass::method2));
methods.push_back(Fnc(&MyClass::method3));
printf("%d\n", methods[0].compareWith(Fnc(&MyClass::method1))); //should be "1"
printf("%d\n", methods[1].compareWith(Fnc(&MyClass::method2))); //should be "1"
printf("%d\n", methods[2].compareWith(Fnc(&MyClass::method3))); //should be "1"
printf("%d\n", methods[0].compareWith(Fnc(&MyClass::method2))); //should be "0"
}

Answer 1

With a hint given by #joergbrech i made up some kind of hash that easily distinguishes one pointer to member function from another. And it works with overloads too.
The solution is very simple, yet may not be very robust. But it works nicely for me. The benefit is that it works with C++11 and doesnt require any fancy stuff :)
Working example:
//WARINING: sizeof(pointer-to-member-function) may not always be <= 8
//Consider changing the hash to be an array!
//I write it as uint64_t for the sake of ease.
template<typename R, class Class, class... Args>
uint64_t getId(R(Class::*ptr)(Args...)) {
uint64_t id = 0;
memcpy(&id, &ptr, sizeof(ptr));
return id;
}
class MyClass
{
public:
void test(int a) {
}
void test(double a) {
}
void test2(int a) {
}
};
int main() {
//Now every pointer-to-member-function may be simply represented by a number
//and compared at any time.
//static_cast is needed for functions that are overloaded if you wonder.
cout << getId(static_cast<void(MyClass::*)(int)>(&MyClass::test))
<< getId(static_cast<void(MyClass::*)(double)>(&MyClass::test))
<< getId(static_cast<void(MyClass::*)(double)>(&MyClass::test))
<< getId(&MyClass::test2);
//Output was: 4389464 4389304 4389304 4389616
// ^ != ^ == ^ != ^
return 0;
}