c++ - 有没有办法在没有 reinterpret_cast 的情况下保存多种类型的函数指针？

Question

我有一些代码处理许多指向不同签名函数的指针。这是一个片段:

#include <unordered_map>

// Simple type id system
template<typename> void type_id(){}
using type_id_t = void(*)();

// value type of our map. We reinterpret functions pointer to this type
using held_type = void(*)();

// actual function type.
template<typename T>
using funct_type = T(*)();

int main() {
    std::unordered_map<type_id_t, held_type> function_map;

    function_map.emplace(type_id<int>, reinterpret_cast<held_type>(
        static_cast<func_type<int>>([]() -> int { return 42; });
    ));

    function_map.emplace(type_id<double>, reinterpret_cast<held_type>(
        static_cast<func_type<double>>([]() -> double { return 9.4; });
    ));

    // later on

    // prints 42
    std::cout << reinterpret_cast<func_type<int>>(function_map[type_id<int>])();

    // prints 9.4
    std::cout << reinterpret_cast<func_type<double>>(function_map[type_id<double>])();
}        

有没有一种方法可以在无需大量开销且无需重新解释转换的情况下实现类似的结果？

Answer 1

如果您可以稍微修改一下您的函数，您可以通过反转流程并删除返回类型来实现它。
这是我的意思的一个例子:

#include <unordered_map>
#include <iostream>

template<typename T>
void call(T t, void *ptr) {
    *static_cast<T *>(ptr) = t;
}

// Simple type id system
template<typename> void type_id() {}
using type_id_t = void(*)();

// value type of our map. We reinterpret functions pointer to this type
using held_type = void(*)(void *);

// actual function type.
template<typename T>
using funct_type = T(*)();

int main() {
    std::unordered_map<type_id_t, held_type> function_map;

    function_map.emplace(type_id<int>, +[](void *ptr){ return call(42, ptr); });
    function_map.emplace(type_id<double>, +[](void *ptr) { call(9.4, ptr); });

    // prints 42
    int i;
    function_map[type_id<int>](&i);
    std::cout << i << std::endl;

    // prints 9.4
    double d;
    function_map[type_id<double>](&d);
    std::cout << d << std::endl;
}

在 wandbox 上查看它的启动和运行情况.

当您查询function_map 时，您可能可以使用变量的类型来选择type_id 的正确特化。只需将所有内容隐藏在函数模板之后。