> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C++ Variadic Template A variadic template is a class, function, alias (C++11), or variable (C++14) template that accepts an arbitrary number of template arguments. This is achieved through the use of a **parameter pack**, which represents a comma-separated list of zero or more arguments. The ellipsis operator (`...`) is the core syntactic element used to declare and expand parameter packs. Its placement determines whether it is defining a pack or expanding one. ## Supported Template Types Variadic templates can be applied across four distinct template categories: ```cpp theme={"dark"} #include #include // 1. Class Template template class Tuple {}; // 2. Function Template template void process(Ts... args) {} // 3. Alias Template (C++11) template using my_tuple = std::tuple; // 4. Variable Template (C++14) template constexpr std::size_t size_v = sizeof...(Ts); ``` ## Core Terminology and Syntax 1. **Template Parameter Pack:** Declared in the template parameter list. It represents zero or more types (or non-types/templates). 2. **Function Parameter Pack:** Declared in the function signature. It represents zero or more function arguments. 3. **Pack Expansion:** The process of unpacking the parameter pack into separate, comma-separated arguments. ```cpp theme={"dark"} // 'Types' is a template parameter pack template // 'args' is a function parameter pack void evaluate(Types... args) { // 'args...' is a pack expansion targetFunction(args...); } ``` ## Pack Expansion Mechanics When a pack is expanded, the compiler duplicates the pattern preceding the ellipsis for each element in the pack, separating them with commas. ```cpp theme={"dark"} #include void consume(int, double); // Example target function template void forward_all(Args&&... args) { // The pattern is 'std::forward(args)' // If Args contains {int, double}, this expands to: // consume(std::forward(args1), std::forward(args2)); consume(std::forward(args)...); } ``` ## Processing Parameter Packs Because parameter packs cannot be indexed directly (e.g., `args[0]`), C++ provides specific mechanisms to iterate over or process the elements within a pack. ### 1. Recursive Instantiation (Pre-C++17) The traditional method for processing a pack involves compile-time recursion. This requires two overloads: a base case to terminate the recursion, and a variadic template that isolates the first argument and recursively passes the remaining pack. ```cpp theme={"dark"} void handle(int); // Example target function // 1. Base case: invoked when the parameter pack is empty void process() {} // 2. Recursive step: peels off the first argument (Head) // and leaves the rest in the pack (Tail) template void process(Head head, Tail... tail) { handle(head); // Process the isolated argument process(tail...); // Recursively expand the remaining pack } ``` ### 2. Fold Expressions (C++17) C++17 introduced fold expressions, which apply a binary operator to all elements of a parameter pack directly, eliminating the need for recursive boilerplate. There are four types of fold expressions: * **Unary Right Fold:** `(pack op ...)` expands to `arg1 op (arg2 op arg3)` * **Unary Left Fold:** `(... op pack)` expands to `(arg1 op arg2) op arg3` * **Binary Right Fold:** `(pack op ... op init)` expands to `arg1 op (arg2 op (arg3 op init))` * **Binary Left Fold:** `(init op ... op pack)` expands to `((init op arg1) op arg2) op arg3` ```cpp theme={"dark"} #include template bool all_true(Args... args) { // Unary left fold using the logical AND operator return (... && args); } template void print_all(Args... args) { // Unary right fold using the comma operator. // The pattern being expanded is 'void(std::cout << args << " ")' (void(std::cout << args << " "), ...); } ``` ## Querying Pack Size The `sizeof...` operator is used to determine the number of elements contained within a parameter pack at compile time. It yields a constant expression of type `std::size_t`. ```cpp theme={"dark"} #include template constexpr std::size_t get_argument_count() { return sizeof...(Args); // Returns the number of types in the pack } ```

Tired of Poor C++ Skills? Fix That With Deep Grasping! Learn More