{"title":"Function Templates","description":null,"content":"A function template is one piece of source code that the compiler stamps out into many real functions, one per type you actually use. The previous lesson covered why templates exist and showed a single-type example. This lesson goes deeper: multiple type parameters, how the compiler figures out which types to use, when you should override its choice with explicit arguments, and how templates interact with regular overloads.\n\n---\n\n# Anatomy of a Function Template\n\nThe shape is always the same: a `template` clause that introduces type parameters, then a function definition that uses those parameters in place of concrete types.\n\n\n```cpp\n#include \n#include \n\ntemplate \nT maxPrice(T a, T b) {\n return (a > b) ? a : b;\n}\n\nint main() {\n std::cout << \"Max int price: \" << maxPrice(199, 249) << std::endl;\n std::cout << \"Max double price: \" << maxPrice(19.99, 14.50) << std::endl;\n std::cout << \"Max name: \" << maxPrice(std::string(\"alice\"), std::string(\"bob\")) << std::endl;\n return 0;\n}\n```\n\n\n`typename` and `class` mean the same thing in this position. `typename T` is the modern convention because it reads clearly when `T` ends up being something that isn't a class (`int`, `double`, a function pointer).\n\nTwo type parameters are just as easy. Imagine a cart line where the quantity is an `int` and the unit price is a `double`. The line total has a different type from either input, and the template can express that.\n\n\n```cpp\n#include \n\ntemplate \nauto lineTotal(Qty quantity, Price price) {\n return quantity * price;\n}\n\nint main() {\n std::cout << \"3 x $19.99 = \" << lineTotal(3, 19.99) << std::endl;\n std::cout << \"5 x $4 = \" << lineTotal(5, 4) << std::endl;\n return 0;\n}\n```\n\n\nThe return type is `auto`, which tells the compiler \"figure out the type of `quantity * price` and use that\". For `int * double` that's `double`. For `int * int` it's `int`. More on `auto` returns below.\n\n---\n\n# Template Argument Deduction\n\nYou rarely write `maxPrice(199, 249)`. You just write `maxPrice(199, 249)` and let the compiler figure out that `T` is `int`. That process is called template argument deduction.\n\nThe rules sound simple at first: the compiler looks at each argument you passed, matches its type against the parameter pattern, and reads `T` off the match. The wrinkle is that the way you wrote the parameter changes what gets deduced.\n\nThree parameter shapes come up over and over. Each one deduces `T` differently for the same call.\n\n\n```cpp\ntemplate void byValue(T x); // T = stripped-down type\ntemplate void byConstRef(const T& x); // T = stripped-down type\ntemplate void byForwardRef(T&& x); // T may be a reference\n```\n\n\nFor a call like `byValue(prices)` where `prices` is a `std::vector`, `T` deduces to `std::vector` and the function takes a copy. For `byConstRef(prices)`, `T` is still `std::vector` but no copy happens. For `byForwardRef(prices)`, the picture changes: because `T&&` on a template parameter is a forwarding reference, `T` becomes `std::vector&` and the function binds to the original.\n\nYou don't need to memorize the deep mechanics of forwarding references yet (that's a later lesson on move semantics). What matters here is the practical shape:\n\n\n| Parameter shape | What `T` deduces to | What the function receives |\n|------------------|---------------------|----------------------------|\n| `T` (by value) | The naked type, no `const`, no reference | A copy |\n| `const T&` | The naked type, no `const`, no reference | A read-only handle |\n| `T&&` (forwarding reference) | Could be `X` or `X&` depending on the argument | A binding that preserves lvalue/rvalue-ness |\n\n\nFor most everyday templates that just read their arguments, `const T&` is the right default. Use plain `T` for tiny types (`int`, `double`, a pointer) where copying is as cheap as referencing.\n\n\n> **INFO**\n>\n> **Cost:** A template that takes `T` by value copies every argument at every call site. For a `std::vector` that's an O(n) copy. Prefer `const T&` unless you have a reason to copy.\n\n\nThe compiler matches the argument's type against the parameter pattern, peels off cv-qualifiers and references, and reads off `T`. Here is what that pipeline looks like for a single call.\n\n\n```mermaid\nflowchart LR\n A[Call site
maxPrice(199, 249)]:::cyan --> B[Argument types
int, int]:::orange\n B --> C[Match against
parameter pattern T, T]:::orange\n C --> D[Deduce T = int]:::green\n D --> E[Instantiate
maxPrice<int>]:::teal\n E --> F[Compile and call
the int version]:::green\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nOne common surprise: when two arguments must share a type, mixed types fail to deduce.\n\n\n```cpp\ntemplate \nT maxPrice(T a, T b);\n\nmaxPrice(199, 19.99); // error: deduction conflict, T = int from first arg, T = double from second\n```\n\n\nThe compiler sees `T = int` from `199` and `T = double` from `19.99` and refuses to pick one. The fix is either to convert one argument yourself (`maxPrice(199.0, 19.99)`), specify the type explicitly (`maxPrice(199, 19.99)`), or split into two type parameters (`maxPrice(T a, U b)`).\n\n---\n\n# Explicit Template Arguments\n\nSometimes the compiler can't deduce `T`, or you want to override its choice. You spell out the type in angle brackets at the call site.\n\nA common case is when `T` only appears in the return type, not the parameter list. Deduction can't reach into the return type, so it can't figure out `T` on its own.\n\n\n```cpp\n#include \n#include \n\ntemplate \nT parsePrice(const std::string& text) {\n if constexpr (std::is_same_v) {\n return std::stoi(text);\n } else {\n return std::stod(text);\n }\n}\n\nint main() {\n auto cents = parsePrice(\"199\");\n auto dollars = parsePrice(\"19.99\");\n std::cout << \"Cents: \" << cents << \", Dollars: \" << dollars << std::endl;\n return 0;\n}\n```\n\n\nWithout `parsePrice` the call wouldn't compile. The parameter is always `const std::string&`, so `T` has nothing to deduce against.\n\nThe second case is when deduction would pick a type you don't want. Say you have a `findCheapest` template that returns the cheapest item from a container of pointers, and the container holds `Product*` but you want to call into the `Product` interface.\n\n\n```cpp\n#include \n#include \n#include \n\nstruct Product {\n std::string name;\n double price;\n};\n\ntemplate \nconst T* findCheapest(const std::vector& items) {\n const T* best = nullptr;\n for (const auto& item : items) {\n if (!best || item.price < best->price) {\n best = &item;\n }\n }\n return best;\n}\n\nint main() {\n std::vector cart = {\n {\"Mug\", 9.99},\n {\"Notebook\", 4.50},\n {\"Pen\", 1.99}\n };\n const Product* cheapest = findCheapest(cart);\n std::cout << \"Cheapest: \" << cheapest->name << \" at $\" << cheapest->price << std::endl;\n return 0;\n}\n```\n\n\nThe explicit `` is redundant here since deduction would pick the same type, but it documents intent. When code review picks up the call, the reader sees `Product` immediately and doesn't have to chase the container's element type.\n\nYou can also mix: some arguments explicit, the rest deduced. The explicit ones must come first, in order.\n\n\n```cpp\ntemplate \nOut convertPrice(In value) {\n return static_cast(value);\n}\n\nauto cents = convertPrice(19.99); // Out = int (explicit), In = double (deduced)\n```\n\n\n`Out` can't be deduced (only used in the return type), so you pass it. `In` is deduced from the argument. This pattern shows up constantly in conversion and casting helpers.\n\n---\n\n# Default Template Arguments\n\nLike default function arguments, default template arguments let callers omit a type and fall back to a sensible default. Function templates accept defaults since C++11.\n\n\n```cpp\n#include \n#include \n#include \n\ntemplate >\nconst T& pickBest(const std::vector& items, Compare cmp = Compare{}) {\n const T* best = &items[0];\n for (const auto& item : items) {\n if (cmp(item, *best)) {\n best = &item;\n }\n }\n return *best;\n}\n\nint main() {\n std::vector prices = {9.99, 4.50, 1.99, 14.99};\n std::cout << \"Cheapest: $\" << pickBest(prices) << std::endl;\n std::cout << \"Most expensive: $\" << pickBest(prices, std::greater{}) << std::endl;\n return 0;\n}\n```\n\n\nThe first call uses the default `std::less`, which finds the smallest element. The second call passes `std::greater` explicitly to flip the comparison. The default makes the common case clean while leaving the door open for customization.\n\nUnlike default function arguments, default template arguments don't have to be the last parameter, though placing them anywhere else gets fiddly fast. Keep them at the end unless you have a real reason not to.\n\n---\n\n# Function Template Overloading\n\nA function template can coexist with regular functions of the same name, and with other function templates of the same name. The compiler picks the best match using overload resolution rules. The full rule set is long, but two principles cover almost every realistic situation.\n\n**First:** when both a template and a non-template match equally well, the non-template wins.\n\n**Second:** when multiple templates match, the most specialized one wins.\n\nHere's the first rule in action. A generic template handles any type, and a non-template overload handles `std::string` specifically.\n\n\n```cpp\n#include \n#include \n\ntemplate \nvoid printOrder(const T& item) {\n std::cout << \"Order item: \" << item << std::endl;\n}\n\nvoid printOrder(const std::string& item) {\n std::cout << \"Order item (string): \" << item << std::endl;\n}\n\nint main() {\n printOrder(42); // calls template, T = int\n printOrder(19.99); // calls template, T = double\n printOrder(std::string(\"Notebook\")); // calls non-template\n return 0;\n}\n```\n\n\nFor `42` and `19.99`, deduction matches the template exactly with `T = int` and `T = double`. For `std::string(\"Notebook\")`, both the template (with `T = std::string`) and the non-template match equally. The non-template wins on the tie.\n\nThe second rule, \"most specialized wins\", applies when you have two templates that overlap. A template that takes `T*` is more specialized than one that takes `T`, because the pointer version constrains what `T` can be.\n\n\n```cpp\n#include \n#include \n\ntemplate \nvoid printOrder(const T& item) {\n std::cout << \"Generic: \" << item << std::endl;\n}\n\ntemplate \nvoid printOrder(const T* item) {\n std::cout << \"Pointer: \" << (item ? *item : T{}) << std::endl;\n}\n\nint main() {\n std::string name = \"Notebook\";\n printOrder(name); // generic template, T = std::string\n printOrder(&name); // pointer template, T = std::string\n return 0;\n}\n```\n\n\nBoth templates could match the second call (the first with `T = std::string*`, the second with `T = std::string`). The pointer version is more specialized, so it wins.\n\n\n> **INFO**\n>\n> **Cost:** Overload resolution itself is a compile-time cost, not a runtime one. Once the compiler picks a function, the call is a direct call with no extra dispatch.\n\n\nThe flow for a call site looks like this.\n\n\n```mermaid\nflowchart TD\n A[Call site
printOrder(arg)]:::cyan --> B[Collect all
visible candidates]:::orange\n B --> C[Drop candidates that
can't accept the argument]:::orange\n C --> D{Multiple
still viable?}:::teal\n D -->|No, one candidate| E[Pick it]:::green\n D -->|Yes| F{Non-template
ties with template?}:::teal\n F -->|Yes| G[Non-template wins]:::green\n F -->|No| H{Templates
tie?}:::teal\n H -->|Yes| I[Most specialized wins]:::green\n H -->|No, still tied| J[Ambiguous: error]:::red\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nThe \"ambiguous\" outcome is the one that bites in practice. If you add overloads carelessly, you can end up with two candidates that each match the call equally well and neither rule breaks the tie. The compiler refuses to pick and emits an error. The fix is usually to constrain one of the overloads (with explicit types, with SFINAE in older code, or with concepts in C++20) so it stops matching the case you wanted the other to handle.\n\n---\n\n# Returning Deduced Types\n\nFor functions that operate on generic input, the right return type often isn't known until you see the inputs. Modern C++ gives you two tools.\n\n`auto` as a return type tells the compiler \"deduce my return type from the `return` statement\". It works for function templates the same way it works for normal functions.\n\n\n```cpp\n#include \n\ntemplate \nauto add(T a, U b) {\n return a + b; // return type deduced from a + b\n}\n\nint main() {\n std::cout << add(3, 4) << std::endl; // int + int -> int\n std::cout << add(3, 4.5) << std::endl; // int + double -> double\n std::cout << add(2.5, 1.5f) << std::endl; // double + float -> double\n return 0;\n}\n```\n\n\nThe compiler looks at `a + b`, computes its type, and stamps that in as the return type. If you have multiple `return` statements, they must all deduce to the same type or the function is ill-formed.\n\n`auto` strips references and `const` the same way it does for variable declarations. So `auto` deduces a value, never a reference. If you want to return a reference (say, to give the caller a handle into a container without copying), you use `decltype(auto)` instead.\n\n\n```cpp\n#include \n#include \n\ntemplate \ndecltype(auto) firstItem(std::vector& cart) {\n return cart[0]; // operator[] returns T&; decltype(auto) preserves it\n}\n\nint main() {\n std::vector cart = {19.99, 4.50, 9.99};\n firstItem(cart) = 24.99; // assignment works because we returned a reference\n std::cout << \"First price now: \" << cart[0] << std::endl;\n return 0;\n}\n```\n\n\nIf `firstItem` had used plain `auto`, it would have returned a `double` (a copy), and the assignment `firstItem(cart) = 24.99` would have changed a temporary rather than the vector element.\n\n`decltype(auto)` is a power tool. Reach for it when you want to forward whatever type and reference category `return` produces. For everyday code, plain `auto` is what you want.\n\n---\n\n# Implicit vs Explicit Instantiation\n\nA function template by itself doesn't generate machine code. Code only appears when the compiler sees a use of the template with concrete types. That use causes the compiler to **instantiate** the template, meaning it produces a real function with the type parameters filled in.\n\nThe common path is **implicit instantiation**: you call `maxPrice(199, 249)`, the compiler sees the call, it instantiates `maxPrice` automatically. You never write the word \"instantiate\" anywhere. This is what happens 99% of the time.\n\n\n```cpp\ntemplate \nT maxPrice(T a, T b) {\n return (a > b) ? a : b;\n}\n\nint main() {\n maxPrice(199, 249); // implicit instantiation of maxPrice\n maxPrice(19.99, 14.50); // implicit instantiation of maxPrice\n return 0;\n}\n```\n\n\nThe translation unit ends up with two separate functions in the compiled output: one for `int` and one for `double`. They share no machine code with each other, even though they came from one template.\n\n\n> **INFO**\n>\n> **Cost:** Every distinct type you instantiate a template with adds a new function to the binary. A template used with 20 different types compiles into 20 copies of similar machine code. This is called code bloat. For most templates it doesn't matter, but for very large generic functions used with many types it can balloon binary size.\n\n\n**Explicit instantiation** lets you force the compiler to emit a particular instantiation in a specific translation unit, even if nothing in that unit uses it. The syntax has no leading `template <>` clause and uses the type in angle brackets.\n\n\n```cpp\n// in some .cpp file\ntemplate int maxPrice(int, int); // explicit instantiation definition\ntemplate double maxPrice(double, double);\n```\n\n\nThis is mostly useful in two situations: hiding template definitions in a `.cpp` file (so callers in other translation units link against the pre-compiled instantiation) and reducing redundant work when the same template gets instantiated in dozens of translation units. For most lessons in this course, you won't write explicit instantiations, but it's good to recognize the syntax when you see it.\n\nA close cousin is the **explicit instantiation declaration** with `extern`, which tells the compiler \"don't instantiate this here, somebody else will\". It pairs with the definition above in another file and is mostly a build-time optimization for large codebases.\n\n\n```cpp\nextern template int maxPrice(int, int); // declaration, no definition emitted\n```\n\n\nYou can also constrain templates further with techniques like specialization and concepts, but those are tools for shaping which types the template accepts, not for controlling when it's instantiated.\n\n---\n\n# Summary\n\n- A function template is one definition that the compiler stamps out into a real function per set of type arguments it's used with.\n- Template argument deduction reads `T` from the call's argument types. By-value `T` and `const T&` deduce a stripped-down type. `T&&` is a forwarding reference and may deduce a reference type.\n- Use explicit template arguments (`findCheapest(cart)`) when the type only appears in the return type, when deduction picks the wrong type, or when you want to document intent.\n- Function templates accept default template arguments since C++11. Place them at the end of the template parameter list.\n- When a function template and a non-template function tie on overload resolution, the non-template wins. When two templates tie, the most specialized one wins.\n- `auto` return type deduces a value (strips references and `const`). `decltype(auto)` preserves the exact reference and `const` category of the return expression.\n- Each distinct set of type arguments triggers a separate implicit instantiation, producing one function per type combination in the binary.\n\nIn the next lesson, we'll see how the same template machinery applies to classes, letting you write a single `Cart` or `Wishlist` that works for any item type.","pageType":"cpp"}

Function Templates

Get Premium