参数化具有重复类型的元组

Question

我要声明模板：

template <size_t N, class Type> my_tuple
{
   using type = ... //something here
};

例如，这样 my_typle<3, std::string>::type 将与 std::tuple<std::string, std::string, std::string> 相同请展示如何在一行中完成它，也许，使用 std::index_sequence 或来自 boost 的东西或其他什么？或者，也许它不能简单地完成？

UPD

请注意，我不需要 std::array，我需要使用预定义的类型列表对一些变量模板进行参数化。我在这里以 std::tuple 为例。

Answer 1

将 decltype 与 return 类型的函数一起使用 returning tuple:

template<typename T, size_t ... Indices>
auto GetType(std::index_sequence<Indices...>) {
    return std::make_tuple( (Indices,T{})... );
}

template <size_t N, class Type> class my_tuple
{
   using type = decltype(GetType<Type>(std::make_index_sequence<N>())); //something here
};


template<class T>
struct Dummy;

int main(){
    Dummy<my_tuple<3,std::string>::type> d;

d 上的错误给您 tuple<string,string,string>，因此它是您想要的类型。

Answer 2

你可以

template <typename...>
struct cat_tuple_type;
template <typename... T1, typename... T2>
struct cat_tuple_type<std::tuple<T1...>, std::tuple<T2...>>
{
   using type = std::tuple<T1..., T2...>;
};

template <size_t N, class Type> struct my_tuple
{
   static_assert(N>0);
   using type = typename cat_tuple_type<std::tuple<Type>, typename my_tuple<N-1, Type>::type>::type;
};
template <class Type> struct my_tuple <1, Type>
{
   using type = std::tuple<Type>;
};

然后my_typle<3, std::string>::type给出类型std::tuple<std::string, std::string, std::string>.

Answer 3

这很有趣。这是扩展序列的“纯”元编程方法：

template<typename T, typename Seq>
struct expander;

template<typename T, std::size_t... Is>
struct expander<T, std::index_sequence<Is...>> {
    template<typename E, std::size_t>
    using elem = E;

    using type = std::tuple<elem<T, Is>...>;
};

template <size_t N, class Type>
struct my_tuple
{
   using type = typename expander<Type, std::make_index_sequence<N>>::type;
};

我讽刺地说“纯粹”。它更类似于经典的元编程技巧，仅此而已。

参数化具有重复类型的元组

Parameterize of tuple with repeated type

c++

tuples

variadic-templates