Zero Argument Variadic Functions

When you call a variadic function with no arguments, the parameter pack will be empty, and the size of the pack (sizeof...(Args)) will be zero. Depending on how the variadic function is implemented, this may or may not be a valid use case.

Let's consider a few examples:

Example 1: Variadic function that expects at least one argument:

1#include <iostream>
2
3template <typename T, typename... Types>
4void PrintValues(T First, Types... Rest) {  
5  std::cout << First;
6  if constexpr (sizeof...(Rest) > 0) {
7    std::cout << ", ";
8    PrintValues(Rest...);
9  }
10}
11
12int main() {
13  PrintValues();  // Error: no matching function
14}

1error: 'PrintValues': no matching overloaded function found

In this case, calling PrintValues() with no arguments will result in a compilation error because the function expects at least one argument (T First).

Example 2: Variadic function that handles zero arguments:

1#include <iostream>
2
3template <typename... Types>
4void PrintValues(Types... Args) {
5  if constexpr (sizeof...(Args) > 0) {
6    (std::cout << ... << Args) << '\n';
7  } else {
8    std::cout << "No arguments passed\n";
9  }
10}
11
12int main() {
13  // Valid: prints "No arguments passed"
14  PrintValues();
15
16  // Valid: prints "123"
17  PrintValues(1, 2, 3);
18}

1No arguments passed
2123

In this example, the variadic function PrintValues() handles the case when no arguments are passed using an if constexpr statement. If the size of Args is greater than zero, it prints the arguments using a fold expression. Otherwise, it prints a special message indicating that no arguments were passed.

Example 3: Variadic function with a default empty base case:

1#include <iostream>
2
3void PrintValues() {
4  std::cout << "\nNo arguments passed\n"; }
5
6template <typename T, typename... Types>
7void PrintValues(T First, Types... Rest) {
8  std::cout << First;
9  if constexpr (sizeof...(Rest) > 0) {
10    std::cout << ", ";
11  }
12  PrintValues(Rest...);
13}
14
15int main() {
16  // Valid: calls the non-template overload
17  PrintValues();
18
19  // Valid: calls the variadic template
20  PrintValues(1, 2, 3);
21}

1No arguments passed
21, 2, 3
3No arguments passed

In this approach, we provide a non-template overload of PrintValues() that takes no arguments and serves as the base case for the variadic template. When PrintValues() is called with no arguments, it invokes the non-template overload, which prints a special message. When called with arguments, it invokes the variadic template, which recursively prints the arguments.

In summary, calling a variadic function with no arguments is valid if the function is designed to handle that case, either through compile-time conditionals or by providing a non-template base case. If the variadic function expects at least one argument, calling it with no arguments will result in a compilation error.