Как сохранить переменное количество аргументов, используя переменные аргументы шаблона?

Просто используйте лямбда-выражение

// Some function.
int add(int a, int b) {
return a + b;
}

auto lazyFunc = [] { return add(1, 2); };

std::cout << lazyFunc() << std::endl; // Evaluate function and output result.

Если вы действительно хотите создать класс, который оценивает функцию только один раз (лениво), используя переменные шаблоны, вы можете сделать что-то вроде следующего кода.

Я также сделал класс таким, чтобы вам не приходилось создавать новый экземпляр при каждом изменении параметров. Я использую std::tuple сохранить заданные аргументы и сравнить с ранее заданными аргументами. Если аргументы различаются, функция будет переоценена.

Функции передаются и хранятся с использованием std::function обертка, поэтому мне не нужно работать с необработанными указателями на функции (гадость).

#include <iostream>
#include <functional>
#include <utility>
#include <tuple>

template <typename T>
class LazyEvaluation {};

template <typename ReturnType, typename... Params>
class LazyEvaluation<ReturnType(Params...)> {
private:
std::function<ReturnType(Params...)> func_;
ReturnType result;
std::tuple<Params...> oldParams; // Contains the previous arguments.
public:
explicit LazyEvaluation(std::function<ReturnType(Params...)> func)
: func_(std::move(func)) {}
template <typename... Args>
ReturnType operator() (Args&&... args) {
auto newParams = std::make_tuple(std::forward<Args>(args)...);

// Check if new arguments.
if (newParams != oldParams) {
result = func_(std::forward<Args>(args)...);
oldParams = newParams;
std::cout << "Function evaluated" << std::endl;
}

std::cout << "Returned result" << std::endl;
return result;
}
};

int main() {
auto f = [] (int a, int b) {
return a + b;
};

// Specify function type as template parameter.
// E.g. ReturnType(Param1Type, Param2Type, ..., ParamNType)
LazyEvaluation<int(int, int)> ld(f);

std::cout << ld(1, 2) << std::endl;
std::cout << ld(1, 2) << std::endl;
std::cout << ld(3, 4) << std::endl;
}

Выход:

Function evaluated
Returned result
3
Returned result
3
Function evaluated
Returned result
7

Приведено стандартное оборудование для формирования пакетов с переменным индексом:

template <std::size_t... I> struct index_sequence {};
template <std::size_t N, std::size_t... I>
struct make_index_sequence : public make_index_sequence<N-1, N-1, I...> {};
template <std::size_t... I>
struct make_index_sequence<0, I...> : public index_sequence<I...> {};

и вызывать функции с неупакованными аргументами кортежа:

template <typename Function, typename... Types, std::size_t... I>
auto apply_(Function&& f, const std::tuple<Types...>& t, index_sequence<I...>)
-> decltype(std::forward<Function>(f)(std::get<I>(t)...)) {
return std::forward<Function>(f)(std::get<I>(t)...);
}

template <typename Function, typename... Types>
auto apply(Function&& f, const std::tuple<Types...>& t)
-> decltype(apply_(f, t, make_index_sequence<sizeof...(Types)>())) {
return apply_(f, t, make_index_sequence<sizeof...(Types)>());
}

Это довольно просто:

template<typename Function, typename... Params>
class LazyEvaluation {
private:
typedef decltype(std::declval<Function>()(std::declval<Params>()...)) result_type;
// Function to be invoked later
Function f;
// Params for function f
std::tuple<Params...> storedParams;
mutable bool evaluated;
union {
std::aligned_storage<sizeof(result_type)> space;
mutable result_type result;
};

// Method which can be called later to evaluate stored function with stored arguments
void evaluate() const {
// if not evaluated then evaluate
if (! evaluated) {
new (&result) result_type{apply(f, storedParams)};
evaluated = true;
}
}

public:
// Constructor remembers function pointer and parameters
LazyEvaluation(Function f, Params... params)
: f(std::move(f)),
storedParams(std::move(params)...),
evaluated(false)
{}
~LazyEvaluation() {
if (evaluated)
result.~result_type();
}

operator result_type&() {
evaluate();
return result;
}

operator const result_type& () const {
evaluate();
return result;
}
};

template <typename Function, typename... Params>
LazyEvaluation<Function, Params...>
make_lazy(Function&& f, Params&&... params) {
return {std::forward<Function>(f), std::forward<Params>(params)...};
}

Я использовал союз и размещение new сохранить результат оценки так, чтобы он не должен был быть конструируемым по умолчанию типом, а некоторые mutable трюки, чтобы const LazyEvaluator может быть преобразован так же как неконстантный экземпляр.