Concatenating tuples as types

  • A+

I'm trying to practice some template programming. Maybe there's a standard way to do this, and I would be thankful for such answers, but my main goal is to practice the template programming techniques, so I tried to implement it myself:

I need to concatenate multiple tuples, but as types, not like std::cat_tuple does it. So I need something like cat<std::tuple<int, float>, std::tuple<char, bool>, ...> to get std::tuple<int, float, char, bool, ...> as a type.

My current attempt failed with a is not a template error:

/* Concat tuples as types: */ template <typename first_t, typename... rest_t> struct cat {     using type = typename _cat<first_t, typename cat<rest_t...>::type>::type;                           ^^^^ cat is not a template }; template <typename first_t, typename second_t> struct cat<first_t, second_t> {     using type = typename _cat<first_t, second_t>::type;                           ^^^^ cat is not a template }; // Concat two tuples: template <typename, typename> struct _cat; template <typename tuple_t, typename first_t, typename... rest_t> struct _cat<tuple_t, std::tuple<first_t, rest_t...>> {     using type = typename _cat<typename append<first_t, tuple_t>::type, std::tuple<rest_t...>>::type; }; template <typename tuple_t, typename first_t> struct _cat<tuple_t, std::tuple<first_t>> {     using type = typename append<first_t, tuple_t>::type; }; // Prepend element to tuple: template <typename, typename> struct prepend; template <typename elem_t, typename... tuple_elem_t> struct prepend<elem_t, std::tuple<tuple_elem_t...>> {     using type = std::tuple<elem_t, tuple_elem_t...>; }; // Apppend element to tuple: template <typename, typename> struct append; template <typename elem_t, typename... tuple_elem_t> struct append<elem_t, std::tuple<tuple_elem_t...>> {     using type = std::tuple<tuple_elem_t..., elem_t>; }; 

What may be causing the error?

Is this a good approach? It might be solved in a simpler way, but I wanted it to be multi-purpose (with the append/prepend operations etc.).


After reordering the definition a little, your code works fine.

I don't think that there are any guidelines for template meta programming. Probably due to the fact that the C++ committee is enhancing TMP "aggressively" and too few people is using TMP.

Here is my version of Cat, it basically follows the same structure as yours:

template <class, class> struct Cat; template <class... First, class... Second> struct Cat<std::tuple<First...>, std::tuple<Second...>> {     using type = std::tuple<First..., Second...>; }; 


:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: