Variadic Templates in Modern C++

Introduced in C++11, variadic templates are a powerful feature that allows programmers to write functions and classes that can take any number of arguments, of any type. This has significant implications for the flexibility and reusability of code.

What are Variadic Templates in Modern C++

A variadic template is a template that can take an arbitrary number of arguments. Before C++11, if you wanted a function that could take an unspecified number of arguments, you had to resort to solutions like function overloading, or using C-style variadic functions with va_list. With variadic templates, you have a much cleaner and type-safe method.

The Basic Idea behind ariadic Templates in Modern C++

Let’s consider an example where you need a function log() that can accept a variable number of arguments and print them to the console. For instance:

log(1, 4.3, "Hello");
log('a', "test", 78L, 5);

class Student;
Student obj;

log(3, obj);

There are two critical requirements for our log() function:

  1. It must accept arguments of any type.
  2. It must accept a variable number of arguments.

To meet the first requirement, we’d typically use a template function. A basic version might look like this:

template<typename T>
void log(T obj) 
    std::cout << obj;

However, this function only takes one argument. To meet the second requirement, we need a variadic template function.

Declaring a Variadic Template Function

A function that can take any number of arguments is defined like this:

template<typename T, typename... Args>
void log(T first, Args... args);

In the above declaration, Args... represents a variable number of template parameters.

Implementing the Variadic Function

Defining a variadic template function can be tricky, as you can’t access the variable number of arguments directly. You need to use recursion along with C++’s type deduction mechanism:

template<typename T, typename... Args>
void log(T first, Args... args) 
    std::cout << first << " , ";
    if constexpr (sizeof...(args) > 0) 

Here’s how it works:

  1. It prints the first argument.
  2. It recursively calls log() with the remaining arguments.

When log() is called with no arguments, it reaches the base case of the recursion and stops.

The Call Stack Example

When you call log(2, 3.4, "aaa");, the following happens internally:

  1. log(int, double, const char*) is instantiated and prints 2, then calls log(double, const char*).
  2. log(double, const char*) is instantiated and prints 3.4, then calls log(const char*).
  3. log(const char*) is instantiated and prints "aaa", then calls log() with no arguments.
  4. The recursion stops as there’s no overloaded function of log() that takes no arguments.

Complete Example with Variadic Template in Modern C++

Here’s how you could write and use the log() function:

#include <iostream>

// Function to end the recursion of variadic template function
void log() {
    // This can be empty or used to print something that marks the end of output.

template<typename T, typename... Args>
void log(T first, Args... args) 
    std::cout << first;
    if constexpr (sizeof...(args) > 0)
        std::cout << " , ";
        std::cout << std::endl; // New line for the last element

int main()
    // Calling log() functio with 3 arguments
    log(1 , 4.3 , "Hello");

    // Calling log() functio with 4 arguments
    log('a', "test", 78L, 5);

    // Calling log() functio with 2 arguments
    log("sample", "test");

    return 0;


1 , 4.3 , Hello
a , test , 78 , 5
sample , test

Important Points about Variadic Template in C++11

  • When using variadic templates, recursion is a common pattern to process arguments.
  • Be careful with the number of recursive calls; too many could lead to a stack overflow.
  • Since C++17, you can use fold expressions to process arguments, which can be more efficient and concise.


By using variadic templates, developers have a robust and type-safe way to create functions and classes that are highly flexible and can handle any number of arguments of any type. This feature is a powerful addition to the C++ language, greatly expanding the potential for generic programming.

Leave a Comment

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Scroll to Top