C++ function templates and argument deduction

Without templates, larger(3, 7), larger(2.5, -1.0) and larger('q', 'k') need three functions with the same body, one per type, and every new type needs one more copy. A function templatefunction template: A function written with template parameters, such as template <typename T> T larger(T a, T b), from which the compiler writes a separate function for each list of template arguments that a call needs. keeps the body once: from template <typename T> T larger(T a, T b) the compiler writes larger<int>, larger<double> and larger<char> itself, working out T from the arguments of each call.

You will see the functions the compiler writes, predict the T it deduces from references, arrays and string literals, settle calls such as larger(1, 2.5) whose arguments propose two types, and read the errors both compilers print when a type lacks an operation the body uses. Every example ran with Apple clang 21 and GCC 16.

One template replaces an overload for every type

The line template <typename T> introduces a template parametertemplate parameter: A name declared in a template's parameter list, such as T in template <typename T> or N in template <std::size_t N>, that stands for a type or a value chosen each time the template is used. named T, and the rest is an ordinary function that uses T wherever a type would go. class means the same as typename in that line; this track writes typename. Here is the template with five calls of it, run on both compilers:

// One function template, called with four types: the compiler writes a larger() for each type.
#include <compare>
#include <print>

template <typename T>
T larger(T a, T b) {
    return a > b ? a : b;
}

struct Version {
    int major;
    int minor;
    auto operator<=>(const Version&) const = default;  // gives Version the > that larger() needs
};

int main() {
    std::println("{}", larger(3, 7));
    std::println("{}", larger(2.5, -1.0));
    std::println("{}", larger('q', 'k'));
    std::println("{}", larger<double>(4, 6.5));
    Version newer = larger(Version{1, 10}, Version{1, 4});
    std::println("{}.{}", newer.major, newer.minor);
}

7
2.5
q
6.5
1.10

The template works for any type that supports what its body does with T: copying a value and comparing two values with >. Numbers and characters have > built in, and Version gets it from its defaulted operator<=>, the three-way comparisonthree-way comparison: The operator <=> (C++20): one comparison that says whether a value is less than, equal to or greater than another, or unordered with it. Defaulted, it compares the members in declaration order, and the compiler rewrites <, <=, > and >= in terms of it. More in “C++ structs, aggregates and designated initialisers”, which compares major first and minor second, so version 1.10 beats version 1.4. The fourth call, larger<double>(4, 6.5), names the template argumenttemplate argument: The type or value that fills a template parameter in one use of a template, such as int in larger<int>. It is written in angle brackets after the template's name, or deduced from the arguments of a call. in angle brackets instead of letting the compiler work it out; a later section shows when that is necessary.

The compiler writes one function per type

A template is not compiled on its own. Each time a call needs it with a new type, the compiler instantiatesinstantiation: The compiler writing a real function or class from a template for particular template arguments, such as larger<int> from larger, the first time a use needs it. Each instantiation is compiled as a function or class of its own. it: it puts the type in place of T and compiles the result as a separate function. Step through the five calls of larger.cpp and watch which call makes a new function and which one reuses a function made before:

Five calls produced four functions, because larger<double>(4, 6.5) reuses the larger<double> that the call with two doubles needed already. The object file shows them. nm -C lists the functions an object file defines, with their C++ names:

from session import run

# Compile only (-c), then list the functions each object file defines whose name contains "larger".
run("""
clang++ -std=c++23 -c larger.cpp -o larger.o && nm -C -j larger.o | grep larger
g++-16 -std=c++23 -c larger.cpp -o larger-gcc.o && nm -C -j larger-gcc.o | grep larger
""")

$ clang++ -std=c++23 -c larger.cpp -o larger.o && nm -C -j larger.o | grep larger
Version larger<Version>(Version, Version)
char larger<char>(char, char)
double larger<double>(double, double)
int larger<int>(int, int)
$ g++-16 -std=c++23 -c larger.cpp -o larger-gcc.o && nm -C -j larger-gcc.o | grep larger
Version larger<Version>(Version, Version)
char larger<char>(char, char)
double larger<double>(double, double)
int larger<int>(int, int)

Both compilers agree, and the names carry the template argument: larger<int> and larger<char> are as distinct as two functions with different names. Each instantiation is compiled and optimised on its own, which is why heavy use of templates costs build time and program size, a cost a later lesson of this module measures. The diagram sums up the path of every call: deduction first, then one compiled function or an error.

Errors appear when a template is instantiated

Nothing in the declaration of larger says that T needs a > operator; the requirement is hidden in the body. So when a type lacks it, the error is reported inside the template, at the line that uses it, and only when a call makes the compiler instantiate the template for that type:

// larger() asks for a > b. Point has no > operator, so larger<Point> cannot be compiled.
template <typename T>
T larger(T a, T b) {
    return a > b ? a : b;
}

struct Point {
    int x;
    int y;
};

int main() {
    Point p{1, 2};
    Point q{3, 4};
    Point r = larger(p, q);
    return r.x;
}

from session import run

run("""
clang++ -std=c++23 -c no_greater.cpp
g++-16 -std=c++23 -c no_greater.cpp
""")

$ clang++ -std=c++23 -c no_greater.cpp
no_greater.cpp:4:14: error: invalid operands to binary expression ('Point' and 'Point')
    4 |     return a > b ? a : b;
      |            ~ ^ ~
no_greater.cpp:15:15: note: in instantiation of function template specialization 'larger<Point>' requested here
   15 |     Point r = larger(p, q);
      |               ^
1 error generated.
[exit status 1]
$ g++-16 -std=c++23 -c no_greater.cpp
no_greater.cpp: In instantiation of 'T larger(T, T) [with T = Point]':
no_greater.cpp:15:21:   required from here
   15 |     Point r = larger(p, q);
      |               ~~~~~~^~~~~~
no_greater.cpp:4:14: error: no match for 'operator>' (operand types are 'Point' and 'Point')
    4 |     return a > b ? a : b;
      |            ~~^~~
[exit status 1]

Both errors name line 4, inside the template, and both lead back to line 15 of main. Step through what the compiler did, from the call to the error and back along the note:

Read such an error from the instantiation note back to your own code. Clang adds in instantiation of function template specialization 'larger<Point>' requested here and GCC begins with In instantiation of ... [with T = Point] followed by required from here; both then show line 15 of main, which is the line you can change. In real projects the chain between your call and the failing line can be dozens of frames long, through library templates, and the frame to look for is the last one in a file you own. C++20 concepts, covered later in this module, let a template state its requirements in its declaration, so that the compiler can reject a type at the call with a short message.

By value, deduction drops const and decays arrays

Deductiontype deduction: The compiler working out a type from an initializer or an argument instead of reading it from the declaration, as it does for auto, decltype(auto) and the parameters of function templates. More in “C++ auto, decltype and type aliases” compares the type of each argument with the type of the parameter it is passed to, and works out a T that makes them match. Two rules decide most cases:

• When the parameter is taken by value (T), the argument’s references and its top-level consttop-level const: A const that applies to an object itself, as in const int or int* const, rather than to what a pointer or a reference leads to. auto drops it, because the new variable is a separate object. More in “C++ auto, decltype and type aliases” are dropped, because the function gets its own copy anyway, and an array or a function decaysarray decay: The everyday name for the array-to-pointer conversion: a C array used as a value, or passed to a function, turns into a pointer to its first element, and its size is lost. A parameter declared as int a[5] is really int* a. More in “std::array, C arrays and array decay” to a pointer.
• When the parameter is a reference such as const T&, nothing decays: an array stays an array, and only the const already written in the parameter is matched away.

The program below prints the name of each instantiated function. std::source_location, standard since C++20, gives it to the program, and both compilers write the deduced T into that name:

// What does the compiler deduce for T? Each function prints its own name, which the compiler writes with T in it.
#include <print>
#include <source_location>

template <typename T>
void take_copy(T) {
    std::println("{}", std::source_location::current().function_name());
}

template <typename T>
void take_ref(const T&) {
    std::println("{}", std::source_location::current().function_name());
}

int main() {
    const int limit = 10;
    int count = 3;
    int& alias = count;
    int marks[4] = {72, 91, 64, 85};

    take_copy(limit);   // a const int
    take_copy(alias);   // a reference to int
    take_copy(marks);   // an array of 4 ints
    take_copy("pear");  // a string literal, const char[5]

    take_ref(limit);
    take_ref(marks);
    take_ref("pear");
}

from session import run

run("""
clang++ -std=c++23 -Wall -Wextra deduce.cpp -o deduce && ./deduce
g++-16 -std=c++23 -Wall -Wextra deduce.cpp -o deduce-gcc && ./deduce-gcc
""")

$ clang++ -std=c++23 -Wall -Wextra deduce.cpp -o deduce && ./deduce
void take_copy(T) [T = int]
void take_copy(T) [T = int]
void take_copy(T) [T = int *]
void take_copy(T) [T = const char *]
void take_ref(const T &) [T = int]
void take_ref(const T &) [T = int[4]]
void take_ref(const T &) [T = char[5]]
$ g++-16 -std=c++23 -Wall -Wextra deduce.cpp -o deduce-gcc && ./deduce-gcc
void take_copy(T) [with T = int]
void take_copy(T) [with T = int]
void take_copy(T) [with T = int*]
void take_copy(T) [with T = const char*]
void take_ref(const T&) [with T = int]
void take_ref(const T&) [with T = int [4]]
void take_ref(const T&) [with T = char [5]]

The two compilers spell the names differently ([T = int *] and [with T = int*]) and agree on every T. Step through the seven calls and watch each rule act on its argument, or leave it alone:

const int limit and the reference alias both give plain int to take_copy. The array marks becomes int*, and the four-element size is lost, while take_ref(marks) keeps it as int[4]. The string literalstring literal: Text in double quotes in the source, such as "pune": an array of const char holding the characters and a terminating '\0', made before the program starts and kept for its whole run. Writing into one is undefined behaviour. More in “C-style strings and why std::string replaced them” "pear" has the type const char[5], four letters and the terminating zero; passed by value it becomes const char*, and passed to take_ref it gives T = char[5], because the const is already part of const T&.

Two string literals compare as addresses

The decay rule turns two string literals into two pointers, and comparing two pointers with > compares where the text is stored, not the text. Nothing warns about it:

// Two string literals passed to larger(): T is deduced as const char*, so > compares two addresses.
#include <print>
#include <string>

using namespace std::string_literals;  // for the s suffix: "pear"s is a std::string

template <typename T>
T larger(T a, T b) {
    return a > b ? a : b;
}

int main() {
    std::println("larger(\"pear\", \"apple\")   = {}", larger("pear", "apple"));
    std::println("larger(\"apple\", \"pear\")   = {}", larger("apple", "pear"));
    std::println("larger(\"pear\"s, \"apple\"s) = {}", larger("pear"s, "apple"s));
}

// The same call with const T& parameters: the arrays do not decay, and their types differ.
template <typename T>
const T& larger_ref(const T& a, const T& b) {
    return a > b ? a : b;
}

int main() {
    const char* word = larger_ref("pear", "apple");
    return word[0] == 'p' ? 0 : 1;
}

from session import run

run("""
clang++ -std=c++23 -Wall -Wextra literals.cpp -o literals && ./literals
g++-16 -std=c++23 -Wall -Wextra literals.cpp -o literals-gcc && ./literals-gcc
clang++ -std=c++23 -c literals_ref.cpp
g++-16 -std=c++23 -c literals_ref.cpp
""")

$ clang++ -std=c++23 -Wall -Wextra literals.cpp -o literals && ./literals
larger("pear", "apple")   = apple
larger("apple", "pear")   = apple
larger("pear"s, "apple"s) = pear
$ g++-16 -std=c++23 -Wall -Wextra literals.cpp -o literals-gcc && ./literals-gcc
larger("pear", "apple")   = pear
larger("apple", "pear")   = pear
larger("pear"s, "apple"s) = pear
$ clang++ -std=c++23 -c literals_ref.cpp
literals_ref.cpp:8:24: error: no matching function for call to 'larger_ref'
    8 |     const char* word = larger_ref("pear", "apple");
      |                        ^~~~~~~~~~
literals_ref.cpp:3:10: note: candidate template ignored: deduced conflicting types for parameter 'T' ('char[5]' vs. 'char[6]')
    3 | const T& larger_ref(const T& a, const T& b) {
      |          ^
1 error generated.
[exit status 1]
$ g++-16 -std=c++23 -c literals_ref.cpp
literals_ref.cpp: In function 'int main()':
literals_ref.cpp:8:34: error: no matching function for call to 'larger_ref(const char [5], const char [6])'
    8 |     const char* word = larger_ref("pear", "apple");
      |                        ~~~~~~~~~~^~~~~~~~~~~~~~~~~
  • there is 1 candidate
    • candidate 1: 'template<class T> const T& larger_ref(const T&, const T&)'
      literals_ref.cpp:3:10:
          3 | const T& larger_ref(const T& a, const T& b) {
            |          ^~~~~~~~~~
      • template argument deduction/substitution failed:
        •   deduced conflicting types for parameter 'const T' ('char [5]' and 'char [6]')
          literals_ref.cpp:8:34:
              8 |     const char* word = larger_ref("pear", "apple");
                |                        ~~~~~~~~~~^~~~~~~~~~~~~~~~~
[exit status 1]

Apple clang says apple is the larger word and GCC says pear, whichever order the arguments come in: each compiler lays out the two literals in its own way, and the standard does not order the addresses of unrelated objects. With std::string arguments, written "pear"s thanks to the s suffix of std::string_literals, the comparison reads the characters and both compilers agree that pear comes after apple. The reference version fails for a different reason: the literals keep their array types, char[5] and char[6], and those are two different types for one T.

When the arguments disagree, name the type

Deduction considers each argument on its own and never converts one to make them agree. That is why larger(1, 2.5) fails, with the same verdict from both compilers:

from session import run

run("""
clang++ -std=c++23 -c conflict.cpp
g++-16 -std=c++23 -c conflict.cpp
""")

$ clang++ -std=c++23 -c conflict.cpp
conflict.cpp:8:16: error: no matching function for call to 'larger'
    8 |     double d = larger(1, 2.5);
      |                ^~~~~~
conflict.cpp:3:3: note: candidate template ignored: deduced conflicting types for parameter 'T' ('int' vs. 'double')
    3 | T larger(T a, T b) {
      |   ^
1 error generated.
[exit status 1]
$ g++-16 -std=c++23 -c conflict.cpp
conflict.cpp: In function 'int main()':
conflict.cpp:8:22: error: no matching function for call to 'larger(int, double)'
    8 |     double d = larger(1, 2.5);
      |                ~~~~~~^~~~~~~~
  • there is 1 candidate
    • candidate 1: 'template<class T> T larger(T, T)'
      conflict.cpp:3:3:
          3 | T larger(T a, T b) {
            |   ^~~~~~
      • template argument deduction/substitution failed:
        •   deduced conflicting types for parameter 'T' ('int' and 'double')
          conflict.cpp:8:22:
              8 |     double d = larger(1, 2.5);
                |                ~~~~~~^~~~~~~~
[exit status 1]

Step through the deduction for that call, then the two fixes that explicit.cpp below runs:

You can settle such a call in three ways, all in the next program:

• Name the template argument. larger<double>(1, 2.5) sets T to double before the call is matched, and the int argument then converts to double the ordinary way.
• Change an argument: larger(1.0, 2.5) gives deduction two doubles.
• Give each parameter its own template parameter, as larger_of_two(A a, B b) does. The return type auto is then the common type of a and b, which is where a trap waits: comparing -1 with 1u converts -1 to an unsigned value first.

A template parameter that appears only in the return type, such as To in convert, can never be deduced from a call, because no argument mentions it. List such parameters first, so that a call names only those (convert<int>(3.99)) and the compiler deduces the rest.

// Three ways to call a template when deduction alone cannot do it.
#include <print>

template <typename T>
T larger(T a, T b) {
    return a > b ? a : b;
}

// To appears only in the return type, so no argument can tell the compiler what it is.
template <typename To, typename From>
To convert(From value) {
    return static_cast<To>(value);
}

// Two type parameters: each argument gets its own type, and the result has their common type.
template <typename A, typename B>
auto larger_of_two(A a, B b) {
    return a > b ? a : b;
}

int main() {
    std::println("larger<double>(1, 2.5) = {}", larger<double>(1, 2.5));
    std::println("convert<int>(3.99)     = {}", convert<int>(3.99));
    std::println("larger_of_two(1, 2.5)  = {}", larger_of_two(1, 2.5));
    std::println("larger_of_two(-1, 1u)  = {}", larger_of_two(-1, 1u));
}

from session import run

run("""
clang++ -std=c++23 -Wall -Wextra explicit.cpp -o explicit && ./explicit
g++-16 -std=c++23 -Wall -Wextra explicit.cpp -o explicit-gcc && ./explicit-gcc
""")

$ clang++ -std=c++23 -Wall -Wextra explicit.cpp -o explicit && ./explicit
explicit.cpp:18:14: warning: comparison of integers of different signs: 'int' and 'unsigned int' [-Wsign-compare]
   18 |     return a > b ? a : b;
      |            ~ ^ ~
explicit.cpp:25:49: note: in instantiation of function template specialization 'larger_of_two<int, unsigned int>' requested here
   25 |     std::println("larger_of_two(-1, 1u)  = {}", larger_of_two(-1, 1u));
      |                                                 ^
1 warning generated.
larger<double>(1, 2.5) = 2.5
convert<int>(3.99)     = 3
larger_of_two(1, 2.5)  = 2.5
larger_of_two(-1, 1u)  = 4294967295
$ g++-16 -std=c++23 -Wall -Wextra explicit.cpp -o explicit-gcc && ./explicit-gcc
explicit.cpp: In instantiation of 'auto larger_of_two(A, B) [with A = int; B = unsigned int]':
explicit.cpp:25:62:   required from here
   25 |     std::println("larger_of_two(-1, 1u)  = {}", larger_of_two(-1, 1u));
      |                                                 ~~~~~~~~~~~~~^~~~~~~~
explicit.cpp:18:14: warning: comparison of integer expressions of different signedness: 'int' and 'unsigned int' [-Wsign-compare]
   18 |     return a > b ? a : b;
      |            ~~^~~
larger<double>(1, 2.5) = 2.5
convert<int>(3.99)     = 3
larger_of_two(1, 2.5)  = 2.5
larger_of_two(-1, 1u)  = 4294967295

larger_of_two(-1, 1u) returns 4,294,967,295. The usual arithmetic conversionsusual arithmetic conversions: The rules that give both operands of an arithmetic or comparison operator one common type. When a signed and an unsigned integer meet and the unsigned type is at least as wide, the signed value is converted to unsigned, so −1 < v.size() is false. More in “Integer overflow and signed/unsigned conversions” turn -1 into the largest unsigned int before > runs, so the template faithfully returns the “larger” value. Both compilers warn, from inside the instantiation larger_of_two<int, unsigned int>, which is one more reason to compile with -Wall -Wextra: warnings, like errors, are reported for each instantiation.

An auto parameter makes a function a template

C++20 lets you skip the template line. A parameter whose type contains auto makes the function an abbreviated function templateabbreviated function template: A function with auto in the type of a parameter, such as void show(const auto& x) (C++20). Each auto invents a template parameter of its own, so the function is a function template written without a template line., and each auto invents one template parameter of its own:

// C++20 abbreviated function templates: an auto parameter makes the function a template.
#include <iostream>
#include <source_location>
#include <string>

struct Fraction {
    int num;
    int den;
};

std::ostream& operator<<(std::ostream& out, const Fraction& f) {
    return out << f.num << '/' << f.den;
}

// The same as template <typename T> void show(const T& value).
void show(const auto& value) {
    std::cout << value << "  <- " << std::source_location::current().function_name() << '\n';
}

// Each auto is its own template parameter: a and b may have different types.
auto add(auto a, auto b) {
    return a + b;
}

int main() {
    show(42);
    show(std::string("Meera"));
    show(Fraction{3, 4});
    show<double>(7);
    std::cout << add(2, 0.5) << '\n';
    std::cout << add(std::string("C++"), "23") << '\n';
}

from session import run

run("""
clang++ -std=c++23 -Wall -Wextra abbreviated.cpp -o abbreviated && ./abbreviated
g++-16 -std=c++23 -Wall -Wextra abbreviated.cpp -o abbreviated-gcc && ./abbreviated-gcc
""")

$ clang++ -std=c++23 -Wall -Wextra abbreviated.cpp -o abbreviated && ./abbreviated
42  <- void show(const auto &) [value:auto = int]
Meera  <- void show(const auto &) [value:auto = std::string]
3/4  <- void show(const auto &) [value:auto = Fraction]
7  <- void show(const auto &) [value:auto = double]
2.5
C++23
$ g++-16 -std=c++23 -Wall -Wextra abbreviated.cpp -o abbreviated-gcc && ./abbreviated-gcc
42  <- void show(const auto:11&) [with auto:11 = int]
Meera  <- void show(const auto:11&) [with auto:11 = std::__cxx11::basic_string<char>]
3/4  <- void show(const auto:11&) [with auto:11 = Fraction]
7  <- void show(const auto:11&) [with auto:11 = double]
2.5
C++23

void show(const auto& value) is exactly template <typename T> void show(const T& value), so everything above applies to it: deduction follows the same rules, every type gets its own function, and you may still name the type, show<double>(7). Clang calls the invented parameter value:auto and GCC auto:11; the names differ, the meaning does not. add(auto a, auto b) has two independent placeholders, so it accepts an int with a double, and a std::string with a string literal. The same idea gives generic lambdasgeneric lambda: A lambda with an auto parameter, or a template parameter list since C++20, whose operator() is a template, so one lambda works for every argument type its body supports, as [](auto x) { return x + x; } does. More in “C++ lambdas: captures and generic lambdas”, such as [](const auto& x) { ... }, which C++14 already had.

Which form to write depends on what the function needs. Answer the three questions in the table for a function of your own:

std::max is a template that returns a reference

std::max, std::min and std::clamp in <algorithm> are function templates with the same deduction rules as larger: std::max(1, 2.5) fails in the same way, and std::max<double>(1, 2.5) settles it. std::ranges::max takes a whole range, and std::max({4, 9, 2}) takes a braced list:

// The standard library's function templates for the same job.
#include <algorithm>
#include <print>
#include <vector>

int main() {
    std::vector<int> runs{48, 112, 7, 64};
    int count = 3;

    std::println("std::max(3, 7)           = {}", std::max(3, 7));
    std::println("std::max<double>(1, 2.5) = {}", std::max<double>(1, 2.5));
    std::println("std::max({{4, 9, 2}})      = {}", std::max({4, 9, 2}));
    std::println("std::ranges::max(runs)   = {}", std::ranges::max(runs));

    auto best = std::max(count, 5);  // a copy of the larger value: safe
    std::println("best = {}", best);

    // std::max returns a reference. Here it refers to the temporary 5, which is destroyed at the semicolon,
    // so reading top afterwards would be undefined behaviour. Both compilers warn.
    [[maybe_unused]] const int& top = std::max(count, 5);
}

from session import run

run("""
clang++ -std=c++23 -Wall -Wextra standard_max.cpp -o standard_max && ./standard_max
g++-16 -std=c++23 -Wall -Wextra standard_max.cpp -o standard_max-gcc && ./standard_max-gcc
""")

$ clang++ -std=c++23 -Wall -Wextra standard_max.cpp -o standard_max && ./standard_max
standard_max.cpp:20:55: warning: temporary bound to local reference 'top' will be destroyed at the end of the full-expression [-Wdangling]
   20 |     [[maybe_unused]] const int& top = std::max(count, 5);
      |                                                       ^
1 warning generated.
std::max(3, 7)           = 7
std::max<double>(1, 2.5) = 2.5
std::max({4, 9, 2})      = 9
std::ranges::max(runs)   = 112
best = 5
$ g++-16 -std=c++23 -Wall -Wextra standard_max.cpp -o standard_max-gcc && ./standard_max-gcc
standard_max.cpp: In function 'int main()':
standard_max.cpp:20:33: warning: possibly dangling reference to a temporary [-Wdangling-reference]
   20 |     [[maybe_unused]] const int& top = std::max(count, 5);
      |                                 ^~~
standard_max.cpp:20:55: note: 'const int' temporary created here
   20 |     [[maybe_unused]] const int& top = std::max(count, 5);
      |                                                       ^
std::max(3, 7)           = 7
std::max<double>(1, 2.5) = 2.5
std::max({4, 9, 2})      = 9
std::ranges::max(runs)   = 112
best = 5

Unlike larger, std::max returns a reference to one of its arguments, which saves a copy of large values but can outlive the argument. Step through the last line of the program and watch what top refers to when the statement ends:

In const int& top = std::max(count, 5); the reference refers to the temporarytemporary object: An unnamed object made while an expression is evaluated, such as the std::string that city + ' Central' produces. It is destroyed at the end of the full expression that made it, unless a reference bound to it keeps it alive. More in “std::string and std::string_view” 5, which is destroyed at the end of the statement, so top is a dangling referencedangling reference: A reference whose object has already been destroyed, such as one returned from a function to its own local variable. Reading or writing through it is undefined behaviour, even when the program happens to print the right value. More in “C++ references: lifetime extension and dangling”. Clang flags it by default (-Wdangling), GCC once -Wextra turns on -Wdangling-reference. Keep the result by value, auto best = std::max(count, 5);.

Practise: clamp_to and count_matching

generic.h declares two function templates for you to write. clamp_to(value, low, high) limits a value to a range, and count_matching(range, pred) counts the elements of any range for which a predicate returns true. The sample tests use them with ints, doubles, chars, strings, a std::vector, a std::array and a plain array.

// Starter code for "Your turn": write clamp_to and count_matching.
#pragma once
#include <cstddef>

// low if value is below low, high if value is above high, otherwise value itself.
// The caller makes sure that low <= high.
template <typename T>
T clamp_to(T value, T low, T high) {
    // TODO
    (void)value;
    (void)low;
    (void)high;
    return T{};
}

// How many elements of range make pred(element) return true. range is anything a range-for loop can walk:
// a std::vector, a std::string, a std::array, a plain array.
template <typename Range, typename Pred>
std::size_t count_matching(const Range& range, Pred pred) {
    // TODO
    (void)range;
    (void)pred;
    return 0;
}

// Sample tests for generic.h. Build: clang++ -std=c++23 -Wall -Wextra generic_tests.cpp -o generic_tests
#include <array>
#include <print>
#include <string>
#include <vector>
#include "generic.h"

int checks = 0;
int failures = 0;

void check(bool ok, const char* what) {
    ++checks;
    if (!ok) {
        ++failures;
        std::println("FAIL {}", what);
    }
}

int main() {
    check(clamp_to(42, 0, 100) == 42, "an int inside the range stays as it is");
    check(clamp_to(-3, 1, 100) == 1, "an int below the range becomes low");
    check(clamp_to(250, 0, 100) == 100, "an int above the range becomes high");
    check(clamp_to(7.5, 0.0, 5.0) == 5.0, "doubles work too");
    check(clamp_to('q', 'a', 'f') == 'f', "and chars");
    check(clamp_to(std::string("mango"), std::string("banana"), std::string("cherry")) == "cherry",
          "strings compare in dictionary order");

    std::vector<int> scores{35, 72, 18, 90, 41};
    check(count_matching(scores, [](int s) { return s >= 40; }) == 3, "three scores of at least 40");
    check(count_matching(std::string("banana"), [](char c) { return c == 'a'; }) == 3, "three a's in banana");
    std::array<double, 3> readings{0.5, -1.25, 2.0};
    check(count_matching(readings, [](double r) { return r < 0; }) == 1, "one negative reading");
    int plain[] = {2, 4, 6, 7};
    check(count_matching(plain, [](int n) { return n % 2 == 0; }) == 3, "a plain array of four ints");
    check(count_matching(std::vector<int>{}, [](int) { return true; }) == 0, "an empty range has no matches");

    std::println("{} of {} checks passed", checks - failures, checks);
    return failures == 0 ? 0 : 1;
}

from session import run

# The sample tests, built against the starter code before any TODO is done.
run("""
clang++ -std=c++23 -Wall -Wextra generic_tests.cpp -o generic_tests && ./generic_tests
g++-16 -std=c++23 -Wall -Wextra generic_tests.cpp -o generic_tests-gcc && ./generic_tests-gcc
""")

$ clang++ -std=c++23 -Wall -Wextra generic_tests.cpp -o generic_tests && ./generic_tests
FAIL an int inside the range stays as it is
FAIL an int below the range becomes low
FAIL an int above the range becomes high
FAIL doubles work too
FAIL and chars
FAIL strings compare in dictionary order
FAIL three scores of at least 40
FAIL three a's in banana
FAIL one negative reading
FAIL a plain array of four ints
1 of 11 checks passed
[exit status 1]
$ g++-16 -std=c++23 -Wall -Wextra generic_tests.cpp -o generic_tests-gcc && ./generic_tests-gcc
FAIL an int inside the range stays as it is
FAIL an int below the range becomes low
FAIL an int above the range becomes high
FAIL doubles work too
FAIL and chars
FAIL strings compare in dictionary order
FAIL three scores of at least 40
FAIL three a's in banana
FAIL one negative reading
FAIL a plain array of four ints
1 of 11 checks passed
[exit status 1]

Only the empty-range check passes before you write anything. Once both templates are right, the program reports 11 of 11 checks and exits with status 0 on both compilers. Write clamp_to with < only, so that it needs nothing more from T than the standard’s std::clamp does, and let count_matching walk the range with a range-based for over const auto&. Then add the call clamp_to(2.5, 0, 10) to the tests and predict the error before you compile it.

Then test what you can predict without a compiler: a deduced T, a count of instantiations, the line to fix. The idea you are least sure of comes up first, and each choice carries a note on the rule it applies:

Interview questions

Fresher · Why does larger(1, 2.5) not compile when larger is declared template <typename T> T larger(T a, T b), and how can you fix the call?

Template argument deduction looks at each argument separately: 1 makes T an int and 2.5 makes it a double. One T cannot be both, and deduction never converts an argument to make the two agree, so no function larger can be made for the call and the compiler reports deduced conflicting types. There are three fixes. Name the argument, larger<double>(1, 2.5), after which 1 converts to double as in any ordinary call; pass arguments of one type, larger(1.0, 2.5); or declare the template with two type parameters, which accepts mixed types but returns their common type, and mixing signed and unsigned integers then gives surprising results such as -1 comparing greater than 1u.

An interviewer usually tests the answer on calls you have not seen. Decide these two:

Two harder questions take templates into code a team owns: a comparison that differs between compilers, and an error message hundreds of lines long:

Key takeaways

• template <typename T> makes a function template; each distinct T a call needs gets its own compiled function, which nm -C lists as larger<int>, larger<double> and so on.
• A template’s requirements are hidden in its body, so errors appear at instantiation: follow the note to the first line in your own code.
• By-value parameters drop references and top-level const and turn arrays and string literals into pointers; const T& parameters keep arrays as arrays.
• Two string literals passed by value compare as addresses, with answers that differ between compilers; pass std::string or std::string_view to compare text.
• Deduction matches each argument against its parameter on its own and never converts; arguments that propose different types make the call fail until you name the type, as in larger<double>(1, 2.5).
• void f(const auto& x) is an abbreviated function template (C++20); prefer std::max, std::clamp and std::ranges::max, and keep their results by value.