如何在数组中存储可变参数模板函数指针并完成赋值？

核心误解与问题点 #

你在模板数组的设计和使用上存在三个关键误解：

1. 模板数组的实例化逻辑错误
   你定义的callbacks是模板化的独立数组——每个不同的Args参数都会生成一个完全独立的数组实例。比如callbacks<>（空参数包）是元素类型为bool(*)(IOPin*)的数组，callbacks<bool>是元素类型为bool(*)(IOPin*, const bool&)的数组，这两个数组毫无关联，根本不是同一个数组的不同位置。而fun1和fun2的函数指针类型不匹配，普通数组要求所有元素类型一致，所以你无法将它们存入“同一个数组”。

2. 空参数包的传递方式错误
   表示无可变参数的正确写法是callbacks<>，而不是callbacks<void>。void类型不能被引用，const void&是语法错误，因此编译器直接报错。

3. 未定义引用的本质
   callbacks<bool>[1] = &fun2;出现的未定义引用，本质是模板静态变量需要显式实例化，但这只是次要问题——核心还是你的数组设计思路不符合“存储不同签名函数指针”的需求。

正确实现方案 #

因为fun1和fun2的函数签名不同，无法直接存入普通数组，以下是三种可行的解决方案：

方案1：使用std::variant（C++17及以上） #

std::variant可以存储不同类型的值，完美适配不同签名的函数指针：

#include <variant>

// 原函数定义
static bool fun1(IOPin* obj) { return true; }
static bool fun2(IOPin* obj, const bool& arg) { return arg; }

// 定义包含两种函数指针类型的variant
using CallbackVariant = std::variant<bool(*)(IOPin*), bool(*)(IOPin*, const bool&)>;

// 初始化数组
CallbackVariant callbacks[2] = {&fun1, &fun2};

// 调用示例
int main() {
    IOPin pin;
    // 调用fun1
    std::visit([&pin](auto&& cb) {
        if constexpr (std::is_invocable_v<decltype(cb), IOPin*>) {
            cb(&pin);
        }
    }, callbacks[0]);

    // 调用fun2
    bool arg = true;
    std::visit([&pin, &arg](auto&& cb) {
        if constexpr (std::is_invocable_v<decltype(cb), IOPin*, const bool&>) {
            cb(&pin, arg);
        }
    }, callbacks[1]);
    return 0;
}

方案2：使用std::function统一调用接口 #

如果可以统一参数传递方式（比如用std::any承载可变参数），可以用std::function包装不同函数：

#include <functional>
#include <any>

static bool fun1(IOPin* obj) { return true; }
static bool fun2(IOPin* obj, const bool& arg) { return arg; }

// 统一函数签名：bool(IOPin*, std::any)
using Callback = std::function<bool(IOPin*, std::any)>;

Callback callbacks[2] = {
    // 包装fun1，忽略第二个参数
    [](IOPin* obj, std::any) { return fun1(obj); },
    // 包装fun2，从std::any中取出参数
    [](IOPin* obj, std::any arg) { return fun2(obj, std::any_cast<const bool&>(arg)); }
};

// 调用示例
int main() {
    IOPin pin;
    callbacks[0](&pin, {}); // 调用fun1，传递空参数
    callbacks[1](&pin, true); // 调用fun2，传递bool参数
    return 0;
}

方案3：使用多态基类（复杂场景适配） #

定义抽象基类，用派生类包装不同函数，存储基类指针实现多态：

class CallbackBase {
public:
    virtual ~CallbackBase() = default;
    virtual bool call(IOPin* obj) = 0;
    virtual bool call(IOPin* obj, const bool& arg) = 0;
};

class Fun1Wrapper : public CallbackBase {
public:
    bool call(IOPin* obj) override { return fun1(obj); }
    bool call(IOPin* obj, const bool&) override { return false; } // 无参数时的默认处理
};

class Fun2Wrapper : public CallbackBase {
public:
    bool call(IOPin* obj) override { return false; } // 缺参数时的默认处理
    bool call(IOPin* obj, const bool& arg) override { return fun2(obj, arg); }
};

// 存储基类指针数组
CallbackBase* callbacks[2] = {new Fun1Wrapper(), new Fun2Wrapper()};

// 调用示例
int main() {
    IOPin pin;
    callbacks[0]->call(&pin);
    callbacks[1]->call(&pin, true);

    // 记得释放内存
    delete callbacks[0];
    delete callbacks[1];
    return 0;
}

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