Function Registry + Polymorphism?

I have a series of structures that all inherit from a base struct, and I also have a series of functions that take in a different child struct as an input.

I am trying to create a simple function registry/map using the various functions created. I assumed I would be able to use the base struct for the mapping of the functions, but when I go to insert the functions into the map I run into the error:

error: no matching member function for call to 'insert' registry.insert({"func1", func1});

Here is the code I have written at the moment:

// Standard Includes
#include <functional>
#include <string>
#include <unordered_map>

struct Base
{
};

struct Test1 : Base
{
};

struct Test2: Base
{
};

inline bool func1(Test1 x)
{
    return true;
}

inline bool func2(Test2 x)
{
    return false;
}

using func = std::function<bool(Base)>;

inline std::unordered_map<std::string, func> functionRegistry()
{
    std::unordered_map<std::string, func> registry;

    registry.insert({"func1", func1});
    registry.insert({"func2", func2});

    return registry;
}

I would appreciate any help here if this is even possible (I assume it is, I am probably just doing something silly)!

The code you show doesn't use any kind of polymorphism.

With that said, you can solve your problem by passing the arguments by reference instead of by value. Then insert lambdas into the map, which calls the actual functions using a suitable downcast:

bool func1(Test1& x)
{
    return true;
}

bool func2(Test2& x)
{
    return false;
}

using func = std::function<bool(Base&)>;

std::unordered_map<std::string, func> functionRegistry()
{
    std::unordered_map<std::string, func> registry;

    registry.insert({"func1", [](Base& x) { return func1(static_cast<Test1&>(x)); }});
    registry.insert({"func2", [](Base& x) { return func2(static_cast<Test2&>(x)); }});

    return registry;
}

Note that I removed the inline specifier. Besides changing the linkage of the function, it's merely a suggestion to the compiler. The compiler will, or will not, inline the functions as it seems fit.