How do I print out the arguments of a function using a variadic template?

Question

This example uses a common variadic template and function. I want to print out the arguments passed to f:

#include <iostream>

template <typename T>
void print(T t) 
{
    std::cout << t << std::endl;
}

template <typename...T>
void f(T &&...args) 
{
    print(args...);
    f(args...);
}

int main() 
{
    f(2, 1, 4, 3, 5);
}

But I am getting the following errors:

Compilation finished with errors:<br>
source.cpp: In instantiation of '`void f(T ...)` [with `T = {int, int, int, int, int}`]':<br>
source.cpp:16:20: required from here <br>
source.cpp:10:4: error: no matching function for call to '`print(int&, int&, int&, int&, int&)`'<br>
source.cpp:10:4: note: candidate is:<br>
source.cpp:4:6: note: `template<class T> void print(T)`<br>
source.cpp:4:6: note: template argument deduction/substitution failed: 
source.cpp:10:4: note: candidate expects 1 argument, 5 provided

This is actually my first time using variadic functions and I do not exactly understand how to use them well.

I also do not get why this isn't working and what I can do to help it.

Answer 1

There you go. You had several mistakes in your code, you can see the comments between the lines below:

#include <iostream>

template <typename T>
void print(T t) {
   std::cout << t << std::endl;
}

// Base case, no args
void f() {}

// Split the parameter pack.
// We want the first argument, so we can print it.
// And the rest so we can forward it to the next call to f
template <typename T, typename...Ts>
void f(T &&first, Ts&&... rest) {
    // print it
    print(std::forward<T>(first));
    // Forward the rest.
    f(std::forward<Ts>(rest)...);
}

int main() {
    f(2, 1, 4, 3, 5);
}

Note that using rvalue refs here makes no sense. You're not storing the parameters anywhere, so simply passing them by const reference should do it. That way you'd also avoid using std::forward just to keep the (useless) perfect forwarding.

Therefore, you could rewrite f as follows:

template <typename T, typename...Ts>
void f(const T &first, const Ts&... rest) {
    print(first);
    f(rest...);
}

Answer 2

c++17 Updates!

Since the question is general and in C++17 you can do it better, I would like to give two approaches.

Solution - I

Using fold expression, this could be simply

#include <iostream>
#include <utility>  // std::forward

template<typename ...Args>
constexpr void print(Args&&... args) noexcept
{
   ((std::cout << std::forward<Args>(args) << " "), ...);
}

int main()
{
   print("foo", 10, 20.8, 'c', 4.04f);
}

output:

foo 10 20.8 c 4.04 

(See Live Online)

---

Solution - II

With the help of if constexpr, now we can avoid providing base case/ 0-argument case to recursive variadic template function. This is because the compiler discards the false statement in the if constexpr at compile time.

#include <iostream>
#include <utility>  // std::forward

template <typename T, typename...Ts>
constexpr void print(T&& first, Ts&&... rest) noexcept
{
   if constexpr (sizeof...(Ts) == 0)
   {
      std::cout << first;               // for only 1-arguments
   }
   else
   {
      std::cout << first << " ";        // print the 1 argument
      print(std::forward<Ts>(rest)...); // pass the rest further
   }
}

int main()
{
   print("foo", 10, 20.8, 'c', 4.04f);
}

output

foo 10 20.8 c 4.04

(See Live Online)

Answer 3

You're recursing infinitely. You need to remove one element from the pack each time:

void print() { }                            // 0-argument overload

template <typename Head, typename ...Tail>
void print(Head const & h, Tail const &... t)         // 1+-argument overload
{
    std::cout << h;
    print(t...);
}

You can wrap your function call up with the printing:

template <typename ...Args>
void print_and_f(Args &&... args)
{
    print(args...);
    f(std::forward<Args>(args)...);
}

Usage:

print_and_f(1, 2, 3);  // calls "f(1, 2, 3)" eventually.