Pfthb

I would like to create a tuple type of common element type whose length is known at compile time. For example if I have

static constexpr const std::size_t compiletime_size = 2;

using tuple_int_size_2 = magic (int, compiletime_size);

tuple_str_t_2 should be the same type as std::tuple<int, int>

This can be done with recursion:

#include <tuple>

template <size_t N, typename Head, typename... T>
struct magic 
 using tuple_type = typename magic<N - 1, Head, Head, T...>::tuple_type;
;

template <typename... T>
struct magic<1, T...> 
 using tuple_type = std::tuple<T...>;
;

int main()

 auto t = typename magic<3, int>::tuple_type;
 return 0;

I wonder, though, if std::array would be a much simpler and straight-forward solution to whatever task it is you're trying to solve.

Without recursion, with two declared (non defined) helper functions and a using

template <typename T, std::size_t ... Is>
constexpr auto gft_helper (std::index_sequence<Is...> const &)
 -> decltype(std::make_tuple( ((void)Is, std::declval<T>())... ));

template <typename T, std::size_t N>
constexpr auto get_fixed_tuple ()
 -> decltype(gft_helper<T>(std::make_index_sequence<N>));

template <typename T, std::size_t N>
using tuple_fixed_type = decltype(get_fixed_tuple<T, N>());

The following is a full working example

#include <tuple>
#include <utility>

template <typename T, std::size_t ... Is>
constexpr auto gft_helper (std::index_sequence<Is...> const &)
 -> decltype(std::make_tuple( ((void)Is, std::declval<T>())... ));

template <typename T, std::size_t N>
constexpr auto get_fixed_tuple ()
 -> decltype(gft_helper<T>(std::make_index_sequence<N>));

template <typename T, std::size_t N>
using tuple_fixed_type = decltype(get_fixed_tuple<T, N>());

int main()
 
 auto ft = tuple_fixed_type<long, 3u>;

 static_assert( std::is_same<decltype(ft), std::tuple<long, long, long>> );