使用函数指针的 STL 映射

Question

我开发了一个具有许多内置函数的脚本引擎，因此要调用任何函数，我的代码只是进入 if .. else if .. else if 墙检查名称，但我想制定更有效的解决方案。

我应该使用以字符串作为键、指针作为值的hashmap吗？我怎样才能使用STL图来做到这一点？

编辑： 我想到的另一点是：当然使用映射会强制编译器不要内联函数，但我的低效方法没有因函数调用的必要性而产生任何开销，它只是执行代码。

所以我想知道函数调用生成的开销是否会比使用 if..else 链更好。否则我可以通过在运行时检查字符来最小化比较次数（会更长）但更快）。

Answer 1

好吧，你可以使用 any_map 来存储具有不同签名的函数（但是调用它会很混乱），并且你可以使用 int_map 来调用具有特定签名的函数（看起来更好） 。

int FuncA()
{
    return 1;
}

float FuncB()
{
    return 2;
}


int main()
{
    // Int map
    map<string,int(*)()> int_map;
    int_map["A"] = FuncA;
    // Call it
    cout<<int_map["A"]()<<endl;

    // Add it to your map
    map<string, void(*)> any_map;
    any_map["A"] = FuncA;
    any_map["B"] = FuncB;

    // Call
    cout<<reinterpret_cast<float(*)()>(any_map["B"])()<<endl;
}

Answer 2

我已成功修改 Mohit 的示例 以处理成员函数指针：

#include <string>
#include <iostream>
#include <map>
#include <vector>
#include <typeinfo>
#include <typeindex>
#include <cassert>


template <typename A>
using voidFunctionType = void (A::*)(void);

template <typename A>
struct Interface{

    std::map<std::string,std::pair<voidFunctionType<A>,std::type_index>> m1;

    template<typename T>
    void insert(std::string s1, T f1){
        auto tt = std::type_index(typeid(f1));
        m1.insert(std::make_pair(s1,
                        std::make_pair((voidFunctionType<A>)f1,tt)));
    }

    template<typename T,typename... Args>
    T searchAndCall(A a, std::string s1, Args&&... args){
        auto mapIter = m1.find(s1);
        auto mapVal = mapIter->second;  

        auto typeCastedFun = (T(A::*)(Args ...))(mapVal.first); 

        assert(mapVal.second == std::type_index(typeid(typeCastedFun)));
        return (a.*typeCastedFun)(std::forward<Args>(args)...);
    }
};

class someclass {
    public:
        void fun1(void);
        int fun2();
        int fun3(int a);
        std::vector<int> fun4();
};

void someclass::fun1(void){
    std::cout<<"inside fun1\n";
}

int someclass::fun2(){
    std::cout<<"inside fun2\n";
    return 2;
}

int someclass::fun3(int a){
    std::cout<<"inside fun3\n";
    return a;
}

std::vector<int> someclass::fun4(){
    std::cout<<"inside fun4\n";
    std::vector<int> v(4,100);
    return v;
}

int main(){
    Interface<someclass> a1;
    a1.insert("fun3",&someclass::fun3);
     someclass s;
    int retVal = a1.searchAndCall<int>(s, "fun3", 3);
    return 0;
}

Answer 3

无论您的函数签名是什么：

typedef void (*ScriptFunction)(void); // function pointer type
typedef std::unordered_map<std::string, ScriptFunction> script_map;

// ...

void some_function()
{
}

// ...

script_map m;
m.emplace("blah", &some_function);

// ...

void call_script(const std::string& pFunction)
{
    auto iter = m.find(pFunction);
    if (iter == m.end())
    {
        // not found
    }

    (*iter->second)();
}

请注意，ScriptFunction类型可以泛化为std::function，这样您就可以支持任何可调用的东西，而不是只是函数指针。

Answer 4

在 C++11 中你可以这样做：
该接口只需要返回类型，它会处理调用方的所有其他事情。

#include <string>
#include <iostream>
#include <map>
#include <vector>
#include <typeinfo>
#include <typeindex>
#include <cassert>

void fun1(void){
    std::cout<<"inside fun1\n";
}

int fun2(){
    std::cout<<"inside fun2\n";
    return 2;
}

int fun3(int a){
    std::cout<<"inside fun3\n";
    return a;
}

std::vector<int> fun4(){
    std::cout<<"inside fun4\n";
    std::vector<int> v(4,100);
    return v;
}

// every function pointer will be stored as this type
typedef void (*voidFunctionType)(void); 

struct Interface{

    std::map<std::string,std::pair<voidFunctionType,std::type_index>> m1;

    template<typename T>
    void insert(std::string s1, T f1){
        auto tt = std::type_index(typeid(f1));
        m1.insert(std::make_pair(s1,
                        std::make_pair((voidFunctionType)f1,tt)));
    }

    template<typename T,typename... Args>
    T searchAndCall(std::string s1, Args&&... args){
        auto mapIter = m1.find(s1);
        /*chk if not end*/
        auto mapVal = mapIter->second;

        // auto typeCastedFun = reinterpret_cast<T(*)(Args ...)>(mapVal.first); 
        auto typeCastedFun = (T(*)(Args ...))(mapVal.first); 

        //compare the types is equal or not
        assert(mapVal.second == std::type_index(typeid(typeCastedFun)));
        return typeCastedFun(std::forward<Args>(args)...);
    }
};

int main(){
    Interface a1;
    a1.insert("fun1",fun1);
    a1.insert("fun2",fun2);
    a1.insert("fun3",fun3);
    a1.insert("fun4",fun4);

    a1.searchAndCall<void>("fun1");
    int retVal = a1.searchAndCall<int>("fun3",2);
    a1.searchAndCall<int>("fun2");
    auto temp = a1.searchAndCall<std::vector<int>>("fun4");

    return 0;
}

Answer 5

您还可以使用 Boost.Function 和 Boost.Bind 甚至允许您在某种程度上拥有 异构函数：

typedef boost::function<void, void> fun_t;
typedef std::map<std::string, fun_t> funs_t;
funs_t f;

void foo() {}
void goo(std::string& p) {}
void bar(int& p) {}

f["foo"] = foo;
f["goo"] = boost::bind(goo, "I am goo");
f["bar"] = boost::bind(bar, int(17));

当然，它也可以是兼容原型的函数映射。

Answer 6

上面的答案似乎给出了完整的概述，这仅涉及您的第二个问题：

按键检索映射元素具有 O(log n) 复杂度。通过键检索哈希图的复杂度为 O(1) + 在发生冲突时需要一些额外的东西。因此，如果您的函数名称有一个好的哈希函数，请使用它。您的实施将有一个标准的实施。应该没问题。

但请注意，低于一百个元素的任何元素都不会带来太多好处。

哈希图的唯一缺点是冲突。在你的情况下，哈希图将是相对静态的。您知道您支持的函数名称。因此，我建议您创建一个简单的测试用例，在其中使用所有键调用 unordered_map<...>::hash_function 以确保没有任何冲突。之后，你就可以忘记它了。

快速谷歌搜索哈希函数的潜在改进让我到达那里：

一些好的哈希函数

也许，根据您的命名约定，您可以改进该函数的某些方面。