Templates

A template is a blueprint parameterised over types or values: a function template generates a family of functions, a class template a family of classes. The compiler instantiates a concrete version on use, explicitly or via argument deduction.

Template instantiation is the compiler generating a concrete class or function from a template by substituting arguments. Implicit happens automatically on first use; explicit forces it in a chosen TU and (with extern template) can suppress it elsewhere.

Template type deduction has three cases: by-value (top-level qualifiers stripped), by-reference (qualifiers preserved), and universal reference T&& (deduces lvalue ref via reference collapsing). Arrays and functions decay to pointers in by-value deduction.

The compiler needs the full template definition at every instantiation point. An implementation in a .cpp is invisible to other TUs and causes linker errors. Fix: keep it in the header. Alternative: explicit instantiation plus extern template.

Template specialization provides an alternative implementation for specific arguments. Full specialization fixes all parameters and is written template<>; partial specialization fixes some or adds constraints and is allowed only for class templates — not functions.

Fold expressions (C++17) collapse a parameter pack with a binary operator in four forms: unary right (args op ...), left (... op args), binary right (args op ... op init), left (init op ... op args). Empty-pack identity is defined only for &&, ||, ,.

if constexpr (C++17) discards the not-taken branch at compile time — it need not compile for the current instantiation, letting one template handle type-dependent paths. A regular if requires both branches to compile.

A non-type parameter takes a value, not a type (template<size_t N> struct Array {T data[N];}). Allowed pre-C++20: integral, enum, pointer/reference with linkage, nullptr_t. C++17 added auto; C++20 added structural class types like fixed-size strings.

A pattern followed by ... repeats for each pack element: f(args)... calls f per arg, Ts... expands a type pack, (args + ...) folds. Transformations like f(g(args)...) are allowed; std::index_sequence lets you unpack a tuple.

When references stack, they collapse: any combination with an lvalue ref yields T&, and only T&& && yields T&&. A forwarding reference T&& deduces T as U& for lvalues, so U& && collapses to U&; for rvalues T = U, giving U&&. That's how it preserves value category.

SFINAE (Substitution Failure Is Not An Error): if substituting template arguments yields an invalid type or expression in the immediate context, the compiler silently drops the overload. Powers std::enable_if for conditional overload selection.

A concept is a named compile-time predicate over template parameters used to constrain templates (template<Number T> T add(T,T);). Errors become readable — instead of SFINAE pages, 'T does not satisfy Number'. Concepts rank overloads by subsumption.

A requires-clause constrains a template (requires Number<T>); a requires-expression checks whether operations are valid (requires (T t) { t+t; }). Combined as requires requires (T t) { ... } — outer clause, inner expression.

Static polymorphism selects behaviour by types known at compile time with zero-cost dispatch. Implemented via overloading, template specialisation, CRTP, if constexpr, and concepts. It cannot hold heterogeneous collections but eliminates vtable indirection.

Variadic templates accept any number of type or non-type parameters via a parameter pack (typename... Ts), expanded with .... Recursion was the classical way to process a pack; C++17 fold expressions cover most cases.

Yes — a constructor can be a member function template enabling construction from different argument types. But a templated constructor is never picked as the copy constructor: the compiler always prefers the implicitly generated one.

No — virtual functions cannot be templates. The vtable needs a fixed compile-time size, but a function template can produce an unbounded number of instantiations known only at link time.

Prefixing auto with a concept constrains it: void f(Sortable auto& c) makes the parameter an abbreviated template whose deduced type must satisfy Sortable. The same works on return types: Number auto g();. A mismatch removes the function from overload resolution, not a hard error.

CTAD (C++17) lets you write std::vector v{1,2,3}; and have the compiler deduce std::vector<int>. Guides are synthesised from constructors; if insufficient, supply user ones like template<class It> Container(It,It) -> Container<typename It::value_type>;.

Errors fire deep in the instantiation chain — the compiler prints every step. Tames: C++20 concepts give a one-line 'does not satisfy X', an early static_assert at the call site gives a friendly message, and cppinsights.io helps.

Alias template (template<class T> using Vec = std::vector<T, MyAlloc>;) is a parameterised type name; typedef takes no template parameters. Aliases also avoid typename dependent-name problems. C++20 added CTAD-for-aliases.

A variable template (C++14) is a parameterised constant: template<class T> constexpr T pi = T(3.14159);. Each use with a type instantiates a distinct object. Unlike a function template it isn't called; unlike a class template it names a value, not a type.

CRTP (Curiously Recurring Template Pattern): Derived inherits from Base<Derived>, letting the base call derived methods via static_cast<Derived*>(this) without virtual dispatch. Used for static polymorphism and mixins.

During phase-1 lookup the compiler doesn't search dependent bases, because a specialization could change what Base<T> contains. So an unqualified value is treated as a non-member name and not found. Making it dependent — this->value or Base<T>::value — defers lookup to instantiation, when the base is known.

The detection idiom tests at compile time whether an expression such as T::member is well-formed for a type, with no hard error. std::void_t<...> maps any valid types to void, and a partial specialization keyed on void_t<expr> matches only when expr compiles — otherwise a fallback primary template is chosen.

template class Foo<int>; forces the compiler to instantiate the template here, emitting object code. Pair with extern template in the header so consumers skip implicit instantiation. Speeds builds when many TUs share one instantiation.

Templates are parsed in two phases. Phase 1, at definition: syntax is checked and non-dependent names are looked up. Phase 2, at instantiation: dependent names are looked up in both the definition and instantiation contexts.

Template metaprogramming (TMP) uses the C++ template system as a compile-time computation engine — types and values via recursive instantiation (classic) or constexpr (modern). <type_traits> is the STL face; C++20 concepts and if constexpr clean it up.

Tag dispatch selects an overload by passing an empty tag struct conveying a category — the classic STL example is std::distance dispatching on iterator_category. Modern C++ replaces it with if constexpr or concept-constrained overloads.

Classic TMP used recursive instantiation: a primary template plus base-case specialisation, Factorial<N>::value = N * Factorial<N-1>::value; with Factorial<0>::value = 1. Modern C++ replaces this with if constexpr and consteval.

Inside a template the compiler can't tell whether a dependent name is a type, value, or template — it defaults to value. typename T::nested declares a type; t.template foo<int>() declares a template. C++20 made typename optional where context implies a type.

extern template class Foo<int>; in a header suppresses implicit instantiation in every including TU; one .cpp provides the body via template class Foo<int>;. Avoids redoing parsing and codegen in every TU.

Partial ordering ranks templates by specificity: A is more specialized than B if every argument set matching A also matches B but not the reverse. The compiler checks this by deducing each candidate's parameters from the other's, and the one-way-deducible candidate wins. It applies to both class partial specializations and function overloads.

Three forms: (1) befriend one instantiation — friend void f<int>(MyClass&);; (2) befriend the whole template — template<class T> friend void f(MyClass&);; (3) define a non-template friend inside the class body — the pattern for operator<< so ADL finds it.

A template template parameter takes a template, not a type: template<template<typename> class C> struct Wrap { C<int> v; };. Useful for code that re-instantiates a generic container with different element types — e.g. allocator policies.