上下文

(C++11) 作为一段序列化代码中安全措施的一部分，我想检查函数指针是否已知。 (否则，反序列化机制可能会失败)。

这是一段(简化的)代码，说明了该机制:

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);

序列化现在很容易，因为我们可以查找一个函数并发出名称。同样，反序列化查找名称并发出包装在类中的函数工厂(这是简单的部分)。

注册的工作方式如下:基本上对于每个函数，我将使用函数指针和名称(用于(反)序列化)调用 Register。这里涉及一个宏和一些辅助类来完成管道。例如:

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

RegisterFunction(Testje::test);

这里Fun的类型是f.ex。 void (*fcn)(int, int)。这很好用，因为 test 是一个静态函数，因此不是成员函数。移除“静电”，恐怖开始了……

问题

当我尝试在 MSVC++ 中编译这段代码时，我收到一个错误，告诉我无法散列函数到成员的指针:

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

为了解决这个问题，我尝试将 fcn 转换为另一种指针类型，这似乎也是不允许的。

请注意，成员函数指针不需要是唯一的；由于 Fun 是一个模板，我只需要为每个具有相同签名的成员函数指针分配一个唯一 ID。如果 name 注册了两次，只需抛出异常即可轻松确保其唯一性。

问题

这给我留下了一个简单的问题:什么会起作用？如何检查函数指针是否已注册？

最佳答案

我修改了你的代码，现在它只适用于一个成员函数。这只是一个例子:

// 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);

然后我们可以检查成员函数是否已注册:

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

我知道这是一个糟糕的解决方案，但也许可以改进。

关于c++ - 检查函数指针是否被注册，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/29798442/