C++反射实现中参数类型兼容性检查的解决方案问询

你的反射实现目前只记录了函数的参数个数，但丢失了每个参数的类型信息，这就是为什么传入不匹配参数时会出现未定义行为——reinterpret_cast直接强转了函数指针，完全跳过了类型校验。要解决这个问题，核心是在注册函数时保存每个参数的类型签名，调用时对比实际传入的参数类型是否与注册的一致。

下面是具体的改造方案：

1. 核心思路 #

我们需要扩展函数信息的存储结构，除了函数指针和参数个数，还要保存每个参数的类型标识。C++标准库中的std::type_index（来自<typeindex>头文件）可以用来唯一标识类型，它基于std::type_info，且可以安全地存入容器。

2. 修改后的完整代码 #

#include <iostream>
#include <string>
#include <map>
#include <type_traits>
#include <typeindex>
#include <vector>
#include <stdexcept>

namespace reflection {
typedef void (*__unknown_func)();

// 扩展函数信息结构体，保存参数类型列表
struct FunctionInfo {
    __unknown_func func_ptr;
    size_t arg_count;
    std::vector<std::type_index> arg_types;
};

std::map<std::string, FunctionInfo> functions;

template<typename K, typename V>
inline bool mapContains(const std::map<K, V>& __map, const K& __key) noexcept {
    return __map.find(__key) != __map.end();
}

// 注册函数时，收集每个参数的类型信息
template<typename _Ret, typename ... _Args>
inline void addFunction(const std::string& function_name, _Ret (*__func)(_Args...)) noexcept {
    FunctionInfo info;
    info.func_ptr = reinterpret_cast<__unknown_func>(__func);
    info.arg_count = sizeof...(_Args);
    // 遍历参数包，收集每个参数的type_index
    (info.arg_types.emplace_back(typeid(_Args)), ...);
    functions.insert_or_assign(function_name, info);
}

// 调用函数时，检查参数个数和类型是否匹配
template<typename _Ret, typename ... _Args>
_Ret callFunction(const std::string& function_name, const _Args& ... arguments) {
    if (!mapContains(functions, function_name)) {
        throw std::runtime_error("Function not found: " + function_name);
    }

    const FunctionInfo& info = functions.at(function_name);
    if (sizeof...(_Args) != info.arg_count) {
        throw std::runtime_error("Argument count mismatch for function: " + function_name);
    }

    // 检查每个参数的类型是否匹配
    bool types_match = true;
    size_t idx = 0;
    ((types_match &= (typeid(arguments) == info.arg_types[idx++])), ...);

    if (!types_match) {
        throw std::runtime_error("Argument type mismatch for function: " + function_name);
    }

    // 类型匹配后再调用
    return reinterpret_cast<_Ret (*)(_Args...)>(info.func_ptr)(arguments...);
}
}

int testFunction(long argument) {
    try {
        std::cout << "Success! Argument value: " << argument << std::endl;
    } catch (...) {
        return 0;
    }
    return 1;
}

int main(const int argc, const char* argv[]) {
    reflection::addFunction("run", testFunction);
    
    // 正常调用：参数类型匹配
    reflection::callFunction<int>("run", 93321L);
    
    // 错误调用：参数类型不匹配，会抛出异常
    try {
        reflection::callFunction<int>("run", std::vector<int>{});
    } catch (const std::runtime_error& e) {
        std::cout << "Error: " << e.what() << std::endl;
    }

    std::cin.get();
    return 0;
}

3. 关键细节说明 #

• 类型存储：使用std::type_index来存储参数类型，它是std::type_info的包装类，可以安全地作为容器的元素（std::type_info不能被复制，而std::type_index可以）。
• 参数类型检查：在callFunction中，我们通过折叠表达式遍历传入的参数，逐个对比typeid(arguments)和注册时保存的arg_types，只要有一个类型不匹配就触发错误。
• 异常处理：这里用std::runtime_error抛出错误信息，你可以根据自己的需求改成返回错误码或其他错误处理方式。

4. 注意事项 #

• const和引用的影响：typeid(const int)和typeid(int)是相同的，但typeid(int&)和typeid(int)是不同的。如果你的函数参数是引用类型，调用时传入非引用参数会触发类型不匹配，这是严格的类型校验。如果需要兼容这种情况，可以在注册时对类型做一些“归一化”处理（比如去掉引用、const限定符），但要注意这可能会带来潜在的类型安全问题。
• 未定义行为的避免：只有当类型完全匹配时才调用函数，避免了reinterpret_cast导致的未定义行为。

内容的提问来源于stack exchange，提问作者Ark