能否在C++结构体中声明未指定模板参数的函数模板指针成员？

当然有解决方案！你不需要退而求其次用void*硬写所有类型的函数，C里有几种优雅的方式实现你要的功能，核心思路是用类型擦除来让结构体成员拥有一个统一的类型，同时保留对不同模板实例的调用能力。下面给你三种可行的方案，从现代C到兼容老版本的都有：

方案一：使用std::function实现类型擦除（推荐现代C++环境） #

这是最简洁易用的方式，利用std::function的类型擦除特性，让结构体成员拥有固定类型，同时适配不同的模板函数实例。

#include <function>
#include <nlohmann/json.hpp> // 假设你使用nlohmann/json库，可替换为你实际的JSON库

using json = nlohmann::json;

// 修正后的Parameter结构体，paramIn为固定类型的std::function
struct Parameter {
    const char* name;
    const char* type;
    const char* rawType;
    std::function<void(void*, json&)> paramIn;
};

// 你的通用模板函数不变
template<typename T>
void myParamIn(T* dst, json& param) {
    *dst = param.get<T>();
}

// 辅助函数：生成适配std::function的包装器，自动推导模板参数
template<typename T>
std::function<void(void*, json&)> make_param_in() {
    return [](void* dst, json& param) {
        myParamIn(static_cast<T*>(dst), param);
    };
}

// 最终的参数描述数组，每个元素指定不同的模板实例
Parameter paramDesc_getValue[] = {
    { "value", "double *", "double", make_param_in<double>() },
    { "meta", "int *", "int", make_param_in<int>() }
};

原理说明 #

std::function<void(void*, json&)是一个固定类型，我们用lambda捕获了模板参数T的类型信息，在调用时把void*转换回T*，再调用你的通用myParamIn函数，完美实现了“结构体成员类型固定，每个元素对应不同模板实例”的需求。

方案二：使用多态基类实现类型擦除（适合需要扩展功能的场景） #

如果需要给参数处理逻辑添加更多扩展功能（比如额外的校验、日志），可以用经典的多态方式实现类型擦除：

#include <memory>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

// 定义统一的基类接口
class ParamInHandler {
public:
    virtual ~ParamInHandler() = default; // 必须声明虚析构函数，避免内存泄漏
    virtual void invoke(void* dst, json& param) = 0;
};

// 模板派生类：处理具体类型的参数转换
template<typename T>
class ParamInHandlerImpl : public ParamInHandler {
public:
    void invoke(void* dst, json& param) override {
        myParamIn(static_cast<T*>(dst), param);
    }
};

// 你的通用模板函数不变
template<typename T>
void myParamIn(T* dst, json& param) {
    *dst = param.get<T>();
}

// 结构体中存储基类的智能指针
struct Parameter {
    const char* name;
    const char* type;
    const char* rawType;
    std::unique_ptr<ParamInHandler> paramIn;
};

// 参数描述数组：每个元素创建对应类型的派生类实例
Parameter paramDesc_getValue[] = {
    { "value", "double *", "double", std::make_unique<ParamInHandlerImpl<double>>() },
    { "meta", "int *", "int", std::make_unique<ParamInHandlerImpl<int>>() }
};

原理说明 #

通过基类的虚函数接口，我们把具体类型的处理逻辑封装在派生类中，结构体只需要持有基类指针。调用时通过虚函数自动分发到对应的模板实例实现，这种方式扩展性更强，后续可以给不同类型添加自定义的处理逻辑。

方案三：使用普通函数指针适配（兼容C++98及以上） #

如果你的项目需要兼容老版本C++（不支持std::function或智能指针），可以用模板适配函数来实现：

#include <nlohmann/json.hpp>

using json = nlohmann::json;

// 结构体中使用固定的void*函数指针类型
struct Parameter {
    const char* name;
    const char* type;
    const char* rawType;
    void (*paramIn)(void*, json&);
};

// 你的通用模板函数不变
template<typename T>
void myParamIn(T* dst, json& param) {
    *dst = param.get<T>();
}

// 模板适配函数：将T*转换为void*，适配结构体的函数指针类型
template<typename T>
void paramInAdapter(void* dst, json& param) {
    myParamIn(static_cast<T*>(dst), param);
}

// 参数描述数组：直接传入模板实例化的适配函数
Parameter paramDesc_getValue[] = {
    { "value", "double *", "double", paramInAdapter<double> },
    { "meta", "int *", "int", paramInAdapter<int> }
};

原理说明 #

每个模板实例化的paramInAdapter<T>都是一个独立的函数，其类型恰好是void(*)(void*, json&)，完全符合结构体成员的类型要求。调用时会自动把void*转换回T*，调用你的通用模板函数。

总结 #

这三种方案都不需要为每种类型单独编写重复的函数，只需要维护一个通用的myParamIn模板即可。其中：

• 方案一最简洁，推荐在C++11及以上环境使用；
• 方案二扩展性最强，适合需要复杂逻辑的场景；
• 方案三兼容性最好，适合老版本C++项目。

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