在地图中存储具有不同签名的函数

Question

我正在尝试在 C++ 中创建一个以 string 为键的 map 和一个作为 value 的通用方法，但我不知道这是否可能。我想做这样的事情：

void foo(int x, int y)
{
   //do something
}

void bar(std::string x, int y, int z)
{
   //do something
} 

void main()
{
   std::map<std::string, "Any Method"> map;

   map["foo"] = &foo;      //store the methods in the map
   map["bar"] = &bar;

   map["foo"](1, 2);       //call them with parameters I get at runtime
   map["bar"]("Hello", 1, 2);
}

这可能吗？如果是，我怎么能意识到这一点？

Answer 1

您可以将函数类型键入擦除到容器中，然后提供模板operator()。如果你弄错了，这将抛出std::bad_any_cast。

注意由于类型擦除，您必须在调用站点指定完全匹配的参数，例如std::function<void(std::string)> 与 std::function<void(const char *)> 不同，尽管两者都可以使用 "Hello" 之类的值调用。

#include <any>
#include <functional>
#include <map>
#include <string>
#include <iostream>

template<typename Ret>
struct AnyCallable
{
    AnyCallable() {}
    template<typename F>
    AnyCallable(F&& fun) : AnyCallable(std::function(std::forward<F>(fun))) {}
    template<typename ... Args>
    AnyCallable(std::function<Ret(Args...)> fun) : m_any(fun) {}
    template<typename ... Args>
    Ret operator()(Args&& ... args) 
    { 
        return std::invoke(std::any_cast<std::function<Ret(Args...)>>(m_any), std::forward<Args>(args)...); 
    }
    std::any m_any;
};

void foo(int x, int y)
{
    std::cout << "foo" << x << y << std::endl;
}

void bar(std::string x, int y, int z)
{
    std::cout << "bar" << x << y << z << std::endl;
} 

using namespace std::literals;

int main()
{
    std::map<std::string, AnyCallable<void>> map;
    
    map["foo"] = &foo;      //store the methods in the map
    map["bar"] = &bar;
    
    map["foo"](1, 2);       //call them with parameters I get at runtime
    map["bar"]("Hello, std::string literal"s, 1, 2);
    try {
        map["bar"]("Hello, const char *literal", 1, 2); // bad_any_cast
    } catch (std::bad_any_cast&) {
        std::cout << "mismatched argument types" << std::endl;
    }
    map["bar"].operator()<std::string, int, int>("Hello, const char *literal", 1, 2); // explicit template parameters
    
    return 0;
}

Answer 2

您能做的最多（我不能在这里说最好）就是使用签名擦除。这意味着将指向函数的指针转换为通用签名类型，然后在使用它们之前将它们转换回正确的签名。

这只能在非常特殊的用例（我无法想象现实世界的用例）中完成，并且非常不安全：没有什么能阻止您将错误的参数传递给函数。简而言之：永远不要在真实世界代码中这样做。

话虽如此，下面是一个工作示例：

#include <iostream>
#include <string>
#include <map>

typedef void (*voidfunc)();

void foo(int x, int y)
{
    std::cout << "foo " << x << " " << y << std::endl;
}

void bar(std::string x, int y, int z)
{
    std::cout << "bar " << x << " " << y << " " << z << std::endl;
}

int main()
{
    std::map<std::string, voidfunc> m;
    m["foo"] = (voidfunc) &foo;
    m["bar"] = (voidfunc)& bar;
    ((void(*)(int, int)) m["foo"])(1, 2);
    ((void(*)(std::string, int, int)) m["bar"])("baz", 1, 2);
    return 0;
}

它按预期给出：

foo 1 2
bar baz 1 2

我无法在标准中找到这是否调用未定义的行为，因为关于函数指针转换的说法很少，但我很确定所有常见的编译器都接受这一点，因为它只涉及 函数指针铸造。

Answer 3

您不能将具有不同签名的函数存储在像map 这样的容器中，无论您将它们存储为函数指针还是std ::function<WHATEVER>。在这两种情况下，关于函数签名的信息都是一个且只有一个。

map 中的value 的类型为一，表示其中存储的对象都是同一类型。

因此，如果您的函数具有所有相同的签名，那么这很容易，否则，您必须放弃类型安全并开始走在一个非常危险的领域。 您可以在其中擦除关于存储在地图中的函数的类型信息。 这转化为类似map<string, void*>。