Check if function pointer is registered

Question

Context

(C++11) As part of a safeguard in a piece of serialization code, I want to check if a function pointer is known. (Otherwise, the deserialization mechanism will probably fail).

This is a (simplified) piece of code that illustrates the mechanism:

template <typename Fun>
struct FunctionCallRegistry
{
    static std::unordered_map<Fun, std::string>& FunctionMap()
    {
        static std::unordered_map<Fun, std::string> map;
        return map;
    }

    static void Register(Fun function, std::string name)
    {
        auto& map = FunctionMap();
        auto it = map.find(function);
        if (it == map.end()) 
        {
            map.insert(std::pair<Fun, std::string>(function, name));
            // other code follows...
        }
    }

    static void Ensure(Fun function) 
    {
        auto& map = FunctionMap();
        auto it = map.find(function);
        if (it == map.end())
        {
            throw std::exception("Function not found.");
        }
    }
};

// Registration code:
struct FunctionCallRegistryInitializer
{
    template <typename Ret, typename... Args>
    explicit FunctionCallRegistryInitializer(Ret(*function)(Args...),
                                             const char* name)
    {
        FunctionCallRegistry<Ret(*)(Args...)>::Register(function, name);
    }
};

#define RegisterFunction(fcn) FunctionCallRegistryInitializer fcn_reg_##__COUNTER__(&fcn, #fcn);

Serialization is now easy, given that we can lookup a function and emit the name. Similarly, deserialization looks up the name and emits the function factory wrapped in a class (this is the easy part).

Registration works as follows: basically for each function, I'll call Register with a function pointer and a name (which is used for the (de)serialization). There's a macro involved here and a few helper classes to do the plumbing. E.g.:

struct Testje
{
    static int test(int lhs, int rhs) {
        std::cout << lhs << " + " << rhs << std::endl;
        return lhs + rhs;
    }
};

RegisterFunction(Testje::test);

The type of Fun here is f.ex. void (*fcn)(int, int). This works fine, because test is a static function and hence not a member function. Remove the 'static' and the horror begins...

Problem

When I attempt to compile this code in MSVC++, I get an error that tells me function-to-member pointers cannot be hashed:

error C2338: The C++ Standard doesn't provide a hash for this type. 

In an attempt to solve this, I've tried to cast fcn to another pointer type, which doesn't seem to be allowed as well.

Note that member function pointers aren't required to be unique; I just need a unique ID for each member function pointer with the same signature since Fun is a template. It's also easy to ensure that the name is unique by simply throwing an exception if it's registered twice.

Question

This leaves me with the simple question: what will work? How can I check if a function pointer is registered?

Answer 1

I modify your code, now it works only for one member-function. It is just an example:

// Registration code:
struct FunctionCallRegistryInitializer
{

    // Here I changed Ret(*function) to Ret(T::*function)
    template <typename T, typename Ret, typename... Args>
    explicit FunctionCallRegistryInitializer(Ret(T::*function)(Args...),
                                             const char* name)
    {
        FunctionCallRegistry<Ret(T::*)(Args...)>::Register(function, name);
    }
};

// We need it for use use member-function test like key value in map
namespace std {
    template <> 
    struct hash<decltype(&Testje::test)>
    {
        size_t operator()(decltype(&Testje::test) x) const
        {
            return typeid(x).hash_code();
        }
    };
}

RegisterFunction(Testje::test);

Than we can check whether member-function registered:

FunctionCallRegistry<decltype(&Testje::test)>::Ensure(&Testje::test);

It is terrible solution, I know, but may be it can be improved.

Answer 2

I could not find a way to take the address of a member function in a portable way. But I can propose 2 workarounds.

Wrapping the member function into a simple function

We all know that a member function is equivalent to a function taking its object as first argument. So if we have :

struct Testje
{
    int test(int lhs, int rhs) {
        std::cout << lhs << " + " << rhs << std::endl;
        return lhs + rhs;
    }
};

it is easy to wrap it with

template<class T, int(T::*mf)(int, int)>
int wrapper(T& obj, int lhs, int rhs) {
        return (obj.*mf)(lhs, rhs);
}
...
FunctionCallRegistry<int (*)(Testje&, int, int)> reg;
reg.Register(&(wrapper<Testje, &Testje::test>), "test");

This compiles and runs fine with a C++11 compiler (provided you apply the fixes suggested by Quentin and dyp - see my below implementation)

Implement a hash class for member functions

You cannot use a pointer to member function as a key in an unordered_map because it cannot be directly hashed. But you can implement a hash for it as suggested by Roland W :

class Testje{
public:
    int test(int lhs, int rhs) {
        std::cout << lhs << " + " << rhs << std::endl;
        return lhs + rhs;
    }
    static int myhash(int (Testje::*f)(int, int) f) {
        // for each and every member function with that signature return a different int
        if (f == &Testje::test) {
             return 0;
        }
        return -1;
    }
    class Hash {
    public:
        size_t operator( )(int (Testje::*f)(int, int) f) const {
            return myhash(f);
        }
    };
};

You have then just to change FunctionCallRegistry to use the new hash function :

template <typename Fun, class Hash = std::hash<Fun>>
struct FunctionCallRegistry
{
    // not static to allow multiple registries
    std::unordered_map<Fun, std::string, Hash> _map; 

    std::unordered_map<Fun, std::string, Hash>& FunctionMap() // returns a reference ...
    {
        return _map;
    }

    void Register(Fun function, std::string name)
    {
        std::unordered_map<Fun, std::string, Hash>& map = FunctionMap();
        auto it = map.find(function);
        if (it == map.end())
        {
            map.insert(std::pair<Fun, std::string>(function, name));
            // other code follows...
        }
    }

    void Ensure(Fun function)
    {
        std::unordered_map<Fun, std::string, Hash>& map = FunctionMap();
        auto it = map.find(function);
        if (it == map.end())
        {
            throw std::exception();
        }
    }
};

You can then use it with :

FunctionCallRegistry<int (Testje::*)(int, int), Testje::Hash> reg;

reg.Register(&Testje::test, "test");
reg.Ensure(&Testje::test);

This is a little more complex but you directly register the member functions.

Note : both method transparently accept virtual member functions.

Answer 3

Even though I post this answer, most credits should go to Mikael Kilpeläinen. And even though I don't make it a habit to accept my own answers, I feel this is not my answer anyways and the only one here that absolutely solves it. Thanks Mikael!

As it turns out there was actually a very simple solution. The main observation I should have made is that there aren't that many functions with the exact same signature (which of course includes the class type and arguments) for each type.

The second important observation is that equality comparison is possible for member function pointers.

The result is surprisingly simple: put the functions in a vector or let the hash code simply return a constant (such as 1). To summarize:

template <typename Fun>
struct FunctionCallFactory
{
private:
    static std::vector<std::pair<Fun, std::string>>& FunctionMap()
    {
        static std::vector<std::pair<Fun, std::string>> map;
        return map;
    }

public:
    static void Register(Fun function, std::string name)
    {
        auto& map = FunctionMap();
        for (auto& it : FunctionMap())
        {
            if (it.first == function)
            {
                throw std::exception("Duplicate registration of function. Not allowed.");
            }
        }
        map.push_back(std::pair<Fun, std::string>(function, name));
    }

    // etc.
};

Note that for each Fun a separate instance will be made, which avoids most collisions during the search. As such, a linear scan will work.

If you want to use a hasher and don't want to put Fun in a template, use the typeid of the function as hash value. Implementation of that is quite easy as well.

Answer 4

OK, I've found the worst-case-scenario answer here. Get memory address of member function?

Basically this involves casting the member-function pointer to (void*&).

Let's call this 'plan Z'... it's obviously not portable nor maintainable. I'm just posting it here as 'answer' because it will probably work. Any other answer is imho highly preferable.