在 C++ 17 中将参数包打包、解包并存储在元组中

Question

我有一个函数指针和参数，我想保存这些并可能修改它们并用它们调用函数。

我已经看到了部分答案，但我不确定完整的解决方案会是什么样子，我很抱歉，但我不太了解参数包，以及它们与元组的关系。

这是我试图一起工作的代码：

我有这个基本上只是调用函数，我认为这可以用来将调用保存到“可调用”结构中，以制作一个接口。

来自这个问题： 带有可变参数参数的 C++ 泛型函数调用

template<typename R, typename... Args>
auto call(R(*function)(Args...), Args... args) -> typename std::enable_if<!std::is_same<R, void>::value, R>::type {
    return function(args...);
}

template<typename... Args>
void call(void (*function)(Args...), Args... args) {
    function(args...);
}

这个结构体应该存储参数和函数指针。 （感谢 RaymondChen 指出应该如何正确）

template<typename R, typename... Args>
struct callable
{
    R(*function)(Args...);
    std::tuple<Args...> params;

    callable(Args... argv):
    params(std::make_tuple(argv...))
    {}
};

我仍然不确定如何使用元组实际回调函数，据我所知，我应该以某种方式将元组转回 Args...然后简单地调用它。

我想要实现的目标：

• 保存通话以供稍后使用
• 从正在运行的应用程序创建我自己的调用并用我自己的参数填充它。
• 读出保存的参数以进行某种调试。

Answer 1

如果您已开始将函数及其所需参数存储在

Callable

中，我建议只提供

operator()

重载，用于使用其存储的参数调用

Callable

。

沿线的一些事情：

// Functor to store the function and its parameters
template<typename R, typename... Args>
class Callable /* final */
{
    R(*mFuncPtr)(Args...) { nullptr };  //  function pointer.
    std::tuple<Args...> mParams{};      //  store the parameters as std::tuple

public:
    explicit constexpr Callable(R(*func)(Args...))
        : mFuncPtr{ func } {}

    explicit constexpr Callable(R(*func)(Args...), Args&&... argv)
        : mFuncPtr{ func }, mParams{ std::make_tuple(std::forward<Args>(argv)...) } {}

    // optional setter for mParams
    void set(Args&&... argv)
    {
        mParams = std::make_tuple(std::forward<Args>(argv)...);
    }

    auto operator()() -> std::conditional_t<std::is_void_v<R>, void*, R>
    {
        if constexpr (std::is_void_v<R>) 
        {
            std::apply(mFuncPtr, mParams); // invoke the function pointer with tuple pack. 
            return nullptr;     // Use nullptr for void return type
        }
        else 
        {
            return std::apply(mFuncPtr, mParams);;
        }
    }

    // Print the stored parameters
    void printParams() const
    {
        std::cout << "(";
        printParamsImpl(std::index_sequence_for<Args...>{});
        std::cout << ")\n";
    }

private:
    template<std::size_t... I>
    void printParamsImpl(std::index_sequence<I...>) const
    {
        (..., (std::cout << (I == 0 ? "" : ", ") << std::get<I>(mParams)));
    }
};