> ## 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++ Abbreviated Function Template An abbreviated function template is a C++20 feature that allows the declaration of function templates using the `auto` placeholder type specifier in the function's parameter list, bypassing the need for an explicit `template <typename T>` declaration. When the compiler encounters `auto` in a parameter list, it implicitly generates a standard template type parameter for that function. ## Syntax and Compiler Translation The abbreviated syntax acts as direct syntactic sugar for traditional template declarations. Each instance of `auto` in the parameter list introduces a distinct, independent template parameter. **Single Parameter:** ```cpp theme={"dark"} // Abbreviated syntax void process(auto x); // Equivalent compiler translation template void process(T x); ``` **Multiple Parameters:** Every `auto` generates a unique type parameter. They are not implicitly forced to be the same type. ```cpp theme={"dark"} // Abbreviated syntax void compare(auto a, auto b); // Equivalent compiler translation template void compare(T1 a, T2 b); ``` ## Variadic Abbreviated Function Templates Abbreviated syntax fully supports variadic templates. Using `auto...` implicitly generates a template parameter pack, allowing the function to accept an arbitrary number of arguments of varying types. ```cpp theme={"dark"} // Abbreviated variadic syntax void print(auto... args); // Equivalent compiler translation template void print(Ts... args); ``` ## Constrained Abbreviated Templates Abbreviated function templates integrate directly with C++20 Concepts. You can constrain the implicit template parameter by prepending a concept name to the `auto` keyword. ```cpp theme={"dark"} #include // Abbreviated syntax with a concept constraint void calculate(std::integral auto x, std::floating_point auto y); // Equivalent compiler translation template void calculate(T1 x, T2 y); ``` ## Reference and CV-Qualifiers The `auto` keyword in this context obeys standard template type deduction rules, including the application of `const`, `volatile`, and reference modifiers. Notably, using `auto&&` creates a forwarding reference (often called a universal reference), identical to `T&&` in a traditional template. ```cpp theme={"dark"} // Abbreviated syntax with qualifiers void mutate(const auto& read_only_val, auto&& forwarding_ref); // Equivalent compiler translation template void mutate(const T1& read_only_val, T2&& forwarding_ref); ``` ## Mixing Explicit and Implicit Template Parameters You can mix traditional explicit template parameter lists with abbreviated `auto` parameters. When mixed, the implicit template parameters generated by `auto` are appended to the end of the explicit template parameter list in the order they appear left-to-right. ```cpp theme={"dark"} // Mixed syntax template void transform(T target, auto modifier); // Equivalent compiler translation template void transform(T target, U modifier); ``` ## Technical Considerations **1. Type Enforcement and Scope:** Every `auto` introduces a distinct type parameter. Attempting to enforce type equality inline using `decltype` (e.g., `void func(auto a, std::same_as<decltype(a)> auto b);`) results in a compilation error. Concept constraints applied to `auto` parameters are lifted to the implicitly generated template parameter list, which is evaluated before the function parameters are in scope. To enforce type matching while retaining abbreviated syntax, a trailing `requires` clause must be used, as function parameters are in scope at that point: ```cpp theme={"dark"} #include // Correct way to enforce type matching with abbreviated syntax void func(auto a, auto b) requires std::same_as; ``` Alternatively, traditional template syntax (`template <typename T> void func(T a, T b);`) is generally the preferred approach for enforcing identical types across multiple parameters. **2. Explicit Template Arguments:** Invoking an abbreviated function template with explicit template arguments (e.g., `process<int, double>(x, y)`) is highly brittle. If the function signature is later modified—such as changing an `auto` parameter to a concrete type—it silently alters the arity and indexing of the implicit template parameter list. This shifts the indices of the remaining template parameters, which will break existing explicit template instantiations at the call site.

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