构造对象后将可变参数传递给方法

Question

我正在尝试构建一个模板类，一旦使用其可变参数构造，其成员函数就可以使用这些参数，而无需用户手动将它们插入回去。这段代码（修改自这篇文章）在构造函数中接受参数，并且在运算符重载中不需要它们：

struct FunctionBase
{
    virtual ~FunctionBase() {}
};

template<numeric T, numeric... Args>
struct Function : public FunctionBase
{
public:
    Function(Args... params)
        : argsTuple(params...)
    {}

    const virtual T operator()(T x)
    {
        return callExpr(x, std::index_sequence_for<Args...>{});
    }

protected:
    template<std::size_t... I>
    const T callExpr(T x, std::index_sequence<I...>)
    {
        return expression(x, std::get<I>(argsTuple)...);
    }

    const virtual T expression(T x, Args... params)
    {
        // Do arithmetic operations
        return 0;
    }

    std::tuple<Args...> argsTuple;
};

这里我将构造函数的参数存储在一个元组中，然后使用该元组将它们传递给

expression(T x, Args... params)

中的

callExpr(T x, std::index_sequence<I...>)

。

有没有办法避免中间函数调用，例如

callExpr

和

std::get<I>(argsTuple)...

？目前这种方法非常慢。

Answer 1

有

std::apply

可以避免您自己进行间接操作。

const virtual T operator()(T x)
{
    return std::apply([&](const auto&... args){ return expression(x, args...); },
                      argsTuple);
}

std::function

是另一种选择：

template<numeric T, numeric... Args>
struct Function : public FunctionBase
{
public:
    Function(Args... params) : func([=](T x) { return expression(x, params...); })
    {}

    const virtual T operator()(T x) { return func(x); }

protected:
    const virtual T expression(T x, Args... params)
    {
        // Do arithmetic operations
        return 0;
    }

    std::function<T(T)> func;
};