'How can I generate a tuple of N type T's?

I want to be able to write generate_tuple_type<int, 3> which would internally have a type alias type which would be std::tuple<int, int, int> in this case.

Some sample usage:

int main()
{
    using gen_tuple_t = generate_tuple_type<int, 3>::type;
    using hand_tuple_t = std::tuple<int, int, int>;
    static_assert( std::is_same<gen_tuple_t, hand_tuple_t>::value, "different types" );
}

How can I accomplish this?

c++c++11template-meta-programming


Solution 1:[1]

Fairly straightforward recursive formulation:

template<typename T, unsigned N, typename... REST>
struct generate_tuple_type
{
 typedef typename generate_tuple_type<T, N-1, T, REST...>::type type;
};

template<typename T, typename... REST>
struct generate_tuple_type<T, 0, REST...>
{
  typedef std::tuple<REST...> type;
};

Live example

[Update]

OK, so I was only thinking about modest values of N. The following formulation is more complex, but also significantly faster and less compiler-crushing for large arguments.

#include <tuple>

template<typename /*LEFT_TUPLE*/, typename /*RIGHT_TUPLE*/>
struct join_tuples
{
};

template<typename... LEFT, typename... RIGHT>
struct join_tuples<std::tuple<LEFT...>, std::tuple<RIGHT...>>
{
  typedef std::tuple<LEFT..., RIGHT...> type;
};

template<typename T, unsigned N>
struct generate_tuple_type
{
  typedef typename generate_tuple_type<T, N/2>::type left;
  typedef typename generate_tuple_type<T, N/2 + N%2>::type right;
  typedef typename join_tuples<left, right>::type type;
};

template<typename T>
struct generate_tuple_type<T, 1>
{
  typedef std::tuple<T> type;
};

template<typename T>
struct generate_tuple_type<T, 0>
{
  typedef std::tuple<> type;
};

int main()
{
  using gen_tuple_t = generate_tuple_type<int, 30000>::type;
  static_assert( std::tuple_size<gen_tuple_t>::value == 30000, "wrong size" );
}

Live example

This version performs at most 2*log(N)+1 template instantiations, assuming your compiler memoizes them. Proof left as an exercise for the reader.

Solution 2:[2]

You can use std::make_index_sequence to give you a pack long enough, and then just wrap it in the type you need. No recursion necessary:

template <typename T, size_t N>
class generate_tuple_type {
    template <typename = std::make_index_sequence<N>>
    struct impl;

    template <size_t... Is>
    struct impl<std::index_sequence<Is...>> {
        template <size_t >
        using wrap = T;

        using type = std::tuple<wrap<Is>...>;
    };

public:
    using type = typename impl<>::type;
};

Solution 3:[3]

Check the bottom of this link for an example:

http://en.cppreference.com/w/cpp/utility/integer_sequence.

You'll need to do a little more work to encapsulate the resulting tuple as a type alias, but the crucial construct here is std::integer_sequence and friends.

Solution 4:[4]

This is a simple one liner with Boost.Mp11.

#include <boost/mp11/algorithm.hpp>

int main()
{
    using gen_tuple_t = boost::mp11::mp_repeat_c<std::tuple<int>, 3>;
    using hand_tuple_t = std::tuple<int, int, int>;
    static_assert( std::is_same_v<gen_tuple_t, hand_tuple_t>, "different types" );
}

Sources

This article follows the attribution requirements of Stack Overflow and is licensed under CC BY-SA 3.0.

Source: Stack Overflow

Solution Source
Solution 1
Solution 2 Barry
Solution 3
Solution 4 NoSenseEtAl

Related Questions