can't understand variadic templates in c++

Question

I was reading about variadic templates and I came across this example. The book mentions that to end the recursion process, the function print() is used. I really can't understand its use. Why does the author use this empty print() function?

void print () // can't get why this function is used
{
}

template <typename T, typename... Types>
void print (const T& firstArg, const Types&... args)
{
    std::cout << firstArg << std::endl; // print first argument
    print(args...); // call print() for remaining arguments
}

Answer 1

A variadic expression can capture 0 arguments or more.

Take for example the call print(1). Then T captures int and Types = {} - it captures no arguments. Thus the call print(args...); expands to print();, which is why you need a base case.

---

You don't need the recursion at all. I always use the following debuglog function in my code (modified for your needs):

template<typename F, typename ... Args>
  void
  print(const F& first, const Args&... args) // At least one argument
  {
    std::cout << first << std::endl;
    int sink[] =
      { 0, ((void)(std::cout << args << std::endl), 0)... };
    (void) sink;
  }

Because this variadic function takes at least one argument, you are free to use print(void) for whatever you like now.

Answer 2

It is recursive because the variadic part of the template is reduced each call, for example a call would recursively look like this

print(1, 2, 3, 4, 5)  // firstArg == 1
                      // ...args == 2,3,4,5

print(2, 3, 4, 5)     // firstArg == 2
                      // ...args == 3,4,5

print(3, 4, 5)        // firstArg == 3
                      // ...args == 4,5

print(4, 5)           // firstArg == 4
                      // ...args == 5

print(5)              // firstArg == 5
                      // ...args == {}

print()

The print() is necessary as a base case for when the variadic list is empty.