Although this is totally doable with variadic templates and std::tuple
, the best solution for what you want I think is to just use std::array
. If you simply want a container with N instances of T, the std::array
signature is already template <typename T, std::size_t N> class array
. I think it fits your need exactly.
Having said that, if you really want std::tuple
for some reason you can do it like so:
#include <tuple>
/* Forward declaration. */
template <std::size_t N, typename T>
class Tuple;
/* Convenience type alias. */
template <std::size_t N, typename T>
using TTuple = typename Tuple<N, T>::type;
/* Base case. */
template <typename T>
class Tuple<0, T> {
public:
using type = std::tuple<>;
}; // Tuple<0>
/* Recursive case. */
template <std::size_t N, typename T>
class Tuple {
public:
/* Note the use of std::declval<> here. */
using type = decltype(std::tuple_cat(std::declval<std::tuple<T>>(),
std::declval<TTuple<N - 1, T>>()));
}; // Tuple<N, T>
/* std::declval<> is necessary to support non default constructable classes. */
class NoDefault {
public:
NoDefault() = delete;
}; // Foo
/* Sample use. */
static_assert(std::is_same<TTuple<2, NoDefault>,
std::tuple<NoDefault, NoDefault>>::value, "");
int main() {}
Note: If you don't have access to C++11 but do have access to boost, boost::array
and boost::tuples::tuple
will do fine in lieu of std::array
and std::tuple
.