你不能这样做。
如果在函数中使用可变参数，最好的办法是将这些参数转换为元组。
然而，一个元组与具有任何不同参数列表的任何其他元组都不同，因此您不能将其存储在容器中以便稍后回调。
如果元组是从一个公共基类派生的，那么您就可以在使用之前存储它们（这必须通过一个virtual call()方法进行双重分派）。这样写起来不太方便，因为这意味着几乎要重写std::tuple类型。
如果我是你，我会做相反的事情，也就是说，做一个lambda来调用传递的回调函数，并将它转换为std::function存储在容器中，以备以后调用。
沿着伪代码（未测试）：

template <typename F, typename... Args>
   void registerCallback(F f, Args&&... args)
   {
      // Make a function that's calling the callback and store that instead
      std::function<void()> laterCB = [&] { f(args...); };
      // Simply store in your std::vector<std::function<void()>> container
      Store::getInstance().addSubscriber(laterCB);
   }

   void triggerCB()
   {
       for (auto i : Store::getInstance().getCB()) 
           *i();
   }

• 另一句话：*

这种代码总是非常不安全的，因为参数的类型可以是引用（语法中没有任何东西可以阻止这种情况）。当稍后回调时，引用的对象可能不再存在。如果你不得不写一个库，你最好避免这样做，相反，让你的接口非常严格，以防止这种情况。
不安全使用示例：

// DON'T DO THAT
struct A { ... };
int processA(A & a) { 
  a.foo();
}

if (something())
{
   A a;
   yourLib.registerCallback(processA, a);
}

// Calls processA with a reference on a 
// destructed object 'a' => so it'll crash
yourLib.triggerCB();

你可以这样做。
希望有帮助：-）（我正在使用Qt，可以用std替换qt容器）

class CallbackLambda {

public:
    template<typename F>
    void store_lambda(const QString &key, F &&f) {
        using arg_tuple = typename function_traits<F>::arg_tuple;
        using return_type = typename function_traits<F>::return_type;

        myHash[key] = [f = std::forward<F>(f)](std::any args) -> std::any {
            if constexpr (std::is_same_v<return_type, void>) {
                std::apply(f, std::any_cast<arg_tuple &>(args));
                return {};
            } else {
                return std::apply(f, std::any_cast<arg_tuple &>(args));
            }
        };
    }

    template<typename... Args>
    std::any call(const QString &key, Args... arg) {
        return call_lambda(myHash[key], arg...);
    }
private:
    QHash<QString, std::function<std::any(std::any)>> myHash;

    template<typename T>
    struct function_traits : public function_traits<decltype(&T::operator())> {
    };

    template<typename ClassType, typename ReturnType, typename... Args>
    struct function_traits<ReturnType(ClassType::*)(Args...) const> {
        using arg_tuple = std::tuple<Args...>;
        using return_type = ReturnType;
    };

    template<typename... Args>
    std::any call_lambda(const std::function<std::any(std::any)> &f, Args &&... args) {
        return f(std::make_tuple(std::forward<Args>(args)...));
    }

};

int main() {
    auto manager = CallbackLambda();
    manager.store_lambda("print", []() {
        std::cout << "Hello, world!\n" << std::endl;
    });

    manager.store_lambda("int", [](int x, int y)  {
        std::cout << "The sum of " << x << " and " << y << " is " << (x + y) << std::endl;
        return x + y;
    });

    manager.store_lambda("float", [](float val, float v) {
        std::cout << "Message: " << val << " " << v << std::endl;
    });

    manager.store_lambda("stdString", [](std::string message) {
        std::cout << "Message: " << message << "\n" << std::endl;
    });
    manager.store_lambda("qString", [](QString message) {
        std::cout << "Message: " << message.toStdString() << "\n" << std::endl;
    });
    manager.store_lambda("char", [](const char *message) {
        std::cout << "Message: " << message << "\n" << std::endl;
    });
    manager.store_lambda("double", [](double val, double v) {
        std::cout << "Message: " << val << " " << v << std::endl;
    });

    manager.call("print");
    auto out = manager.call("int", 10, 20);
    std::cout << std::any_cast<int>(out) << std::endl;

    return 0;
}

欢迎来电。
您可能希望编辑call来检查回调是否存在，否则返回nullptr或类似的东西。..
C++存储带有可变参数的回调并获取返回