Variadic Functions

Why use parameter packs instead of just va_args?

I can already write variadic functions in C++ using va_args. Why would I use parameter packs instead?

Abstract art representing computer programming

You're right that C++ has long supported variadic functions using the va_args macros from the C library. However, parameter packs, introduced in C++11 as part of variadic templates, offer several significant advantages:

Type Safety

  • va_args: The types of the arguments are not checked by the compiler. It's the programmer's responsibility to ensure that the arguments match the expected types, leading to potential runtime errors.
  • Parameter Packs: The compiler checks the types at compile-time, catching any mismatches and providing more informative error messages. This ensures that the code is type-safe and less prone to errors.


  • va_args: Arguments are typically passed on the stack, and functions need to manually extract them using va_start, va_arg, and va_end. This incurs runtime overhead.
  • Parameter Packs: Being a compile-time feature, parameter packs allow arguments to be passed directly, and the compiler generates the necessary code to handle them efficiently. This eliminates the runtime overhead associated with va_args.

Expressiveness and Flexibility

  • va_args: Limited control over arguments. They are accessed sequentially, and you need to know the exact number and types in advance.
  • Parameter Packs: Allow for more expressive and flexible code. You can perform operations on each argument using pack expansions, recurse over the pack, and deduce the number and types of arguments at compile-time.

Integration with Templates

  • va_args: Not well-integrated with C++ templates, making them cumbersome to use in template metaprogramming.
  • Parameter Packs: Designed to work seamlessly with templates, enabling powerful metaprogramming techniques and allowing you to write more generic and reusable code.


Here's an example to illustrate the differences between va_args and parameter packs:

#include <cstdarg>
#include <iostream>
#include <string>

// Using va_args
void PrintIntValuesVA(int count, ...) {
  va_list args;
  va_start(args, count);
  for (int i = 0; i < count; ++i) {
    int value = va_arg(args, int);
    std::cout << value << " ";
  std::cout << '\n';

// Using parameter packs with static assertion
// for type safety
template <typename T>
void PrintValuesPack(T value) {
                "Only integral types are supported");
  std::cout << value << '\n';

template <typename T, typename... Types>
void PrintValuesPack(T first, Types... args) {
                "Only integral types are supported");
  std::cout << first << " ";

int main() {
  // OK
  PrintIntValuesVA(3, 1, 2, 3);   

  // Compiles, but undefined behavior
  PrintIntValuesVA(3, 1, 2.0, "three"); 

  // OK
  PrintValuesPack(1, 2, 3);

  // Compilation error: static assertion failed
  // PrintValuesPack(1, 2.0, "three"); 
1 2 3
1 0 -615601108
1 2 3

In the va_args version, calling PrintIntValuesVA(3, 1, 2.0, "three") compiles without errors but results in undefined behavior at runtime because the types do not match the expected int type.

In the parameter pack version, calling PrintValuesPack(1, 2.0, "three") would result in a compilation error because of the static assertion that ensures only integral types are passed. This catches the error at compile-time and ensures type safety.

Additionally, the parameter pack version is more concise and expressive, allowing for compile-time type checking and eliminating the need for manual extraction of arguments.


While va_args are still useful for certain C-style variadic functions, parameter packs offer a more robust, efficient, and expressive solution for variadic functions in modern C++. They provide type safety, eliminate runtime overhead, and integrate seamlessly with C++ templates, making them the preferred choice for modern C++ development.

Answers to questions are automatically generated and may not have been reviewed.

A computer programmer
Part of the course:

Professional C++

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Free, unlimited access

This course includes:

  • 124 Lessons
  • 550+ Code Samples
  • 96% Positive Reviews
  • Regularly Updated
  • Help and FAQ
Free, Unlimited Access

Professional C++

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Screenshot from Warhammer: Total War
Screenshot from Tomb Raider
Screenshot from Jedi: Fallen Order
Contact|Privacy Policy|Terms of Use
Copyright © 2024 - All Rights Reserved