CODEWITHSUNDEEP
c++tuplesvariadic-templates
Alex Chudinov
Alex Chudinov

Reputation: 724

Parameterize of tuple with repeated type

I want to declare template:

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

So that this my_typle<3, std::string>::type,for example, will be the same as this std::tuple<std::string, std::string, std::string> Please, show, how it can be done in one line, maybe, using std::index_sequence or something from boost or whatever? Or maybe it can not be done just simple?

UPD

Please, note I do not need an std::array, I need to parametrize some variable template with predefined list of types. I have used std::tuple as an example here.

Upvotes: 1

Views: 1128

Answers (3)

StoryTeller - Unslander Monica
StoryTeller - Unslander Monica

Reputation: 170289

This is fun. Here's a "pure" meta-programming approach to expand the sequence:

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;
};

I say "pure" ironically. It's more akin to the classic meta-programming tricks, nothing else.

Upvotes: 4

songyuanyao
songyuanyao

Reputation: 173044

You can

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>;
};

Then my_typle<3, std::string>::type gives the type std::tuple<std::string, std::string, std::string>.

Upvotes: 2

rafix07
rafix07

Reputation: 20969

Use decltype with return type of function returning tuple<string,string,...repeated N times>:

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;

error on d gives you tuple<string,string,string>, so it is your desired type.

Upvotes: 3

Related Questions