Аргументы конструктора из кортежа

Question

Предположим, у меня есть шаблон, параметризованный типом класса и количеством типов аргументов. набор аргументов, соответствующих этим типам, хранится в кортеже. Как можно передать их конструктору типа класса?

В почти C++11 код:

template<typename T, typename... Args>
struct foo {
  tuple<Args...> args;
  T gen() { return T(get<0>(args), get<1>(args), ...); }
};

Как можно ... в вызове конструктора заполняться без фиксации длины?

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

Answer 1

Вам нужен механизм шаблонного метапрограммирования, чтобы достичь этого.

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

Предположим, есть класс (шаблон) index_range который инкапсулирует диапазон времени компиляции целых чисел [M, N) и класс (шаблон) index_list который инкапсулирует список целых чисел во время компиляции, вот как бы вы их использовали:

template<typename T, typename... Args>
struct foo
{
    tuple<Args...> args;

    // Allows deducing an index list argument pack
    template<size_t... Is>
    T gen(index_list<Is...> const&)
    {
        return T(get<Is>(args)...); // This is the core of the mechanism
    }

    T gen()
    {
        return gen(
            index_range<0, sizeof...(Args)>() // Builds an index list
            );
    }
};

И вот возможная реализация index_range а также index_list:

//===============================================================================
// META-FUNCTIONS FOR CREATING INDEX LISTS

// The structure that encapsulates index lists
template <size_t... Is>
struct index_list
{
};

// Collects internal details for generating index ranges [MIN, MAX)
namespace detail
{
    // Declare primary template for index range builder
    template <size_t MIN, size_t N, size_t... Is>
    struct range_builder;

    // Base step
    template <size_t MIN, size_t... Is>
    struct range_builder<MIN, MIN, Is...>
    {
        typedef index_list<Is...> type;
    };

    // Induction step
    template <size_t MIN, size_t N, size_t... Is>
    struct range_builder : public range_builder<MIN, N - 1, N - 1, Is...>
    {
    };
}

// Meta-function that returns a [MIN, MAX) index range
template<unsigned MIN, unsigned MAX>
using index_range = typename detail::range_builder<MIN, MAX>::type;

Также обратите внимание, что интересное предложение Jonathan Wakely существует для стандартизации int_seq шаблон класса, который очень похож на то, что я назвал index_list Вот.

Answer 2

C++17 имеет std::make_from_tuple за это:

template <typename T, typename... Args>
struct foo
{
  std::tuple<Args...> args;
  T gen() { return std::make_from_tuple<T>(args); }
};

Answer 3

C++14 добавит стандартную поддержку index_sequence:

template<typename T, typename... Args>
struct foo {
  tuple<Args...> args;
  T gen() { return gen_impl(std::index_sequence_for<Args...>()); }
private:
  template <size_t... Indices>
  T gen_impl(std::index_sequence<Indices...>) { return T(std::get<Indices>(args)...); }
};

Answer 4

Вам нужно будет использовать трюк с индексами, что означает слой косвенности:

template <std::size_t... Is>
struct indices {};
template <std::size_t N, std::size_t... Is>
struct build_indices
  : build_indices<N-1, N-1, Is...> {};
template <std::size_t... Is>
struct build_indices<0, Is...> : indices<Is...> {};

template<typename T, typename... Args>
struct foo {
  tuple<Args...> args;
  T gen() { return gen(build_indices<sizeof...(Args)>{}); }
private:
  template<std::size_t... Is>
  T gen(indices<Is...>) { return T(get<Is>(args)...); }
};

Answer 5

Создайте последовательность индексов от 0 до n-1:

template<size_t... indexes>
struct seq {};

template<size_t n, size_t... indexes>
struct make_seq: make_seq<n-1, n-1, indexes...> {};

template<size_t... indexes>
struct make_seq: make_seq<0, indexes...> {
  typedef seq<indexes...> type;
};

распакуйте их параллельно с вашими аргументами или как указатель get<> в твоем случае.

Цель что-то вроде:

template< typename T, typename Tuple, typename Indexes >
struct repack;

template< typename... Ts, size_t... indexes >
struct repack< tuple<Ts...>, seq<indexes...> > {
  T operator()( tuple<Ts...> const& args ) const {
    return T( get<indexes>(args)... );
  }
};

использование repack в вашем gen как это:

T gen() {
  repack<T, tuple<Args...>, typename make_seq<sizeof...(Args)>::type> repacker;
  return repacker( args );
}