Захвата параметр шаблона переменного числа шаблонных аргументов

Question

У меня есть следующее (неполный, не работоспособное) определение:

template<typename T, std::function<Args(Context&)>... Funcs> 
struct constructor 
{ 
    T construct(Context& ctx) 
    { 
     return T(Funcs(ctx)...); 
    } 
}; 

То, что я хочу, это шаблонный класс - первый аргумент сконструированного типа, и все следующие функции которые будут вызываться, пользовательские шаблоны с std::function s, которые затем вызывают для создания значений для конструктора типа T.

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

std::function<int(Context&)> ind = [](Context&) {return 2;}; 
Constructor<int, ind> c; 
// c.construct(...) returns 2 by calling the constructor int(int) with argument 
//      ind(ctx) - which returns 2. 

Answer 1

Это может быть примерно то, что вы ищете. Имейте в виду, что параметр std::function не может быть параметром шаблона.

template <typename R> using Generator = std::function<R (Context&)>; 

template <typename T, typename Generators, std::size_t... Is> 
T constructImpl(Context& ctx, const Generators& generators, 
       std::index_sequence<Is...>) { 
    return T(std::get<Is>(generators)(ctx)...); 
} 

template <typename T, typename... Args> 
class Constructor { 
    std::tuple<Generator<Args>...> generators; 

public: 
    Constructor(Generator<Args>... generators) 
     : generators(std::move(generators)...) 
    {} 

    T construct(Context& ctx) { 
     return constructImpl<T>(ctx, generators, 
           std::index_sequence_for<Args...>()); 
    } 
}; 

Использование:

Constructor<int, int> c([](Context&) { return 2; }); 
int i = c.construct(context); 
assert(i == 2); 

Answer 2

Я думаю, что ваш Construct может быть просто функцией:

template <typename T, typename... Funcs> 
T construct(Context& ctx, Funcs... funcs) { 
    return T(funcs(ctx)...); 
} 

, использование которых может быть в вашем примере может быть:

int x = construct<int>(ctx, [](Context&) { return 2; }); 

Answer 3

Типы не могут зависеть от данных времени выполнения.

Для того, чтобы позвонить в std::function<X(Y)>, необходимо их время от времени. Таким образом, ваш тип не может зависеть от std::function<X(Y)>, поэтому тип не может использоваться в качестве параметра шаблона.

Теперь это может зависеть от указателя на глобальный объект: это достаточно интересно, если не указано время выполнения до C++.

Как таковой, ваш дизайн в основном ошибочен.

Если вы хотите функцию таким образом, что она возвращает 2, это работает:

template<class...ignored> 
struct Constructor { 
    template<class... also_ignored> 
    Constructor(also_ignored&&...) {} 
    template<class... also_ignored> 
    int construct(also_ignored&&...) { return 2; } 
}; 

это будет проходить юнит-тесты, описанные в вашем О.П., за исключением того, что вы не можете передать ind в Constructor, как это не законны. Однако отбрасывание его из сигнатуры типа не имеет значения.

Если вы хотите больше энергии, мы могли бы сделать это:

template<class T, class... Functors> 
struct Constructor { 

    T construct(Context& ctx) { 
    return T(Functors{}(ctx)...); 
    } 
}; 

в этом случае вам необходимо апатридов функциональные объекты:

struct ind { int operator()(Context&)const{return 2;} }; 

очень нравится, как std::map требует апатридов объектов сравнения.

Если объекты вашей функции требуют состояния, вам необходимо сохранить их копию для Constructor для доступа (возможно, в пределах Constructor), и вам может понадобиться трюк для кортежей и индексов для их хранения. («indexs trick» - полезный Google)