Thread: printing std::tuple recursively

cosider this code snippet

Code:

template <std::size_t N=0, class T>
void print_tuple(const T& t){
    if (N == std::tuple_size<T>::value){
        return;
    }
    
    std::wcout << std::get<N>(t) << L" ";
    print_tuple<N + 1,T>(t);

}

needless to say, T is always std::tuple with printable variable.
and also , needless to say, this does not compile . any ideas?
thanks.

in the other variation , I tried recursively iterate over a variadic template. the solution (which I'm still using today, and it's pretty neat and clever) is to create a "splitting" mechanism-
first overload the function as one which gets Args... args as an argument
second overload the function as one which gets T t, Args... args as arguments (here the compiler recursively splitting the group (arg1, arg2 ... arg_n) to arg1 and all the rest)
third overload the function as not getting any arguments , hence stop the recursion

you can't apply this solution directly with std::tuple - you don't get the arguments as seperated variable but as one pack, which you need to extract each one with std::get..

What does the implementation for `print_tuple<std::tuple_size<T>::value, T>' look like?

other then what I wrote here, there is no other implementation. logicly it's supposed to work , no?

first, I didn't intent to write a shallow answer, I explained exactly why the other solution won't work.
anyway, you example does not include lines 3-5 which supposed to break the recursion

Code:

template <> void print_tuple<0, std::tuple<int, int, int, int>>
(
    const std::tuple<int, int, int, int> & f
)
{
if (0 == std::tuple_size<std::tuple<int, int, int, int>>::value){ //returns false
  return ;
}
    std::get<0>(f); /* ... */
    print_tuple<1, std::tuple<int, int, int, int>>(f);
}

Code:

template <> void print_tuple<1, std::tuple<int, int, int, int>>
(
    const std::tuple<int, int, int, int> & f
)
{
if (1 == std::tuple_size<std::tuple<int, int, int, int>>::value){ //returns false
  return ;
}
    std::get<1>(f); /* ... */
    print_tuple<1, std::tuple<int, int, int, int>>(f);
}

Code:

template <> void print_tuple<2, std::tuple<int, int, int, int>>
(
    const std::tuple<int, int, int, int> & f
)
{
if (2 == std::tuple_size<std::tuple<int, int, int, int>>::value){ //returns false
  return ;
}
    std::get<2>(f); /* ... */
    print_tuple<1, std::tuple<int, int, int, int>>(f);
}

Code:

template <> void print_tuple<3, std::tuple<int, int, int, int>>
(
    const std::tuple<int, int, int, int> & f
)
{
if (0 == std::tuple_size<std::tuple<int, int, int, int>>::value){ //returns false
  return ;
}
    std::get<3>(f); /* ... */
    print_tuple<1, std::tuple<int, int, int, int>>(f);
}

Code:

template <> void print_tuple<4, std::tuple<int, int, int, int>>
(
    const std::tuple<int, int, int, int> & f
)
{
if (4 == std::tuple_size<std::tuple<int, int, int, int>>::value){ //returns true - simply returns
  return ;
}
    std::get<4>(f); /* ... */
    print_tuple<1, std::tuple<int, int, int, int>>(f);
}