13.1 — Function templates

The need for function templates

In previous chapters, you’ve learned how to write functions and classes that help make programs easier to write, safer, and more maintainable. While functions and classes are powerful and flexible tools for effective programming, in certain cases they can also be somewhat limiting because of C++’s requirement that you specify the type of all parameters.

For example, let’s say you wanted to write a function to calculate the maximum of two numbers. You might do so like this:

This function would work great -- for integers. What happens later when you realize your max() function needs to work with doubles? Traditionally, the answer would be to overload the max() function and create a new version that works with doubles:

Note that the code for the implementation of the double version of maximum() is exactly the same as for the int version of max()! In fact, this implementation would work for all sorts of different types: chars, ints, doubles, and if you’ve overloaded the > operator, even classes! However, because C++ requires you to make your variables specific types, you’re stuck writing one function for each type you wish to use.

Having to specify different “flavors” of the same function where the only thing that changes is the type of the parameters can become a maintenance headache and time-waster, and it also violates the general programming guideline that duplicate code should be minimized as much as possible. Wouldn’t it be nice if we could write one version of max() that was able to work with parameters of ANY type?

Welcome to the world of templates.

What is a function template?

If you were to look up the word “template” in the dictionary, you’d find a definition that was similar to the following: “a template is a model that serves as a pattern for creating similar objects”. One type of template that is very easy to understand is that of a stencil. A stencil is an object (e.g. a piece of cardboard) with a shape cut out of it (eg. the letter J). By placing the stencil on top of another object, then spraying paint through the hole, you can very quickly produce stenciled patterns in many different colors! Note that you only need to create a given stencil once -- you can then use it as many times as you like, to create stenciled patterns in whatever color(s) you like. Even better, you don’t have to decide the color of the stenciled pattern you want to create until you decide to actually use the stencil.

In C++, function templates are functions that serve as a pattern for creating other similar functions. The basic idea behind function templates is to create a function without having to specify the exact type(s) of some or all of the variables. Instead, we define the function using placeholder types, called template type parameters. Once we have created a function using these placeholder types, we have effectively created a “function stencil”.

When you call a template function, the compiler “stencils” out a copy of the template, replacing the placeholder types with the actual variable types from the parameters in your function call! Using this methodology, the compiler can create multiple “flavors” of a function from one template! We’ll take a look at this process in more detail in the next lesson.

Creating function templates in C++

At this point, you’re probably wondering how to actually create function templates in C++. It turns out, it’s not all that difficult.

Let’s take a look at the int version of max() again:

Note that there are 3 places where specific types are used: parameters x, y, and the return value all specify that they must be integers. To create a function template, we’re going to replace these specific types with placeholder types. In this case, because we have only one type that needs replacing (int), we only need one template type parameter.

You can name your placeholder types almost anything you want, so long as it’s not a reserved word. However, in C++, it’s customary to name your template types the letter T (short for “Type”).

Here’s our new function with a placeholder type:

This is a good start -- however, it won’t compile because the compiler doesn’t know what “T” is!

In order to make this work, we need to tell the compiler two things: First, that this is a template definition, and second, that T is a placeholder type. We can do both of those things in one line, using what is called a template parameter declaration:

Believe it or not, that’s all we need. This will compile!

Now, let’s take a slightly closer look at the template parameter declaration. We start with the keyword template -- this tells the compiler that what follows is going to be a list of template parameters. We place all of our parameters inside angled brackets (<>). To create a template type parameter, use either the keyword typename or class. There is no difference between the two keywords in this context, so which you use is up to you. Note that if you use the class keyword, the type passed in does not actually have to be a class (it can be a fundamental variable, pointer, or anything else that matches). Then you name your type (usually “T”).

If the template function uses multiple template type parameter, they can be separated by commas:

For classes using more than one type, it’s common to see them named “T1” and “T2”, or other single capital letter names, such as “S”.

One final note: Because the function argument passed in for type T could be a class type, and it’s generally not a good idea to pass classes by value, it would be better to make the parameters and return types of our templated function const references:

Using function templates

Using a function template is extremely straightforward -- you can use it just like any other function. Here’s a full program using our template function:

This will print:


Note that all three of these calls to max() have parameters of different types! Because we’ve called the function with 3 different types, the compiler will use the template definition to create 3 different versions of this function: one with int parameters (named max<int>), one with double parameters (named max<double>), and one with char parameters (named max<char>).

Note that you don’t need to explicitly specify the template type in the function name (e.g. the <int> part of max<int>) so long as the compiler can deduce it from the parameter types.


As you can see, template functions can save a lot of time, because you only need to write one function, and it will work with many different types. Once you get used to writing function templates, you’ll find they actually don’t take any longer to write than functions with actual types. Template functions reduce code maintenance, because duplicate code is reduced significantly. And finally, template functions can be safer, because there is no need to copy functions and change types by hand whenever you need the function to work with a new type!

Template functions do have a few drawbacks, and we would be remiss not to mention them. First, some older compilers do not have very good template support. However, this downside is no longer as much of a problem as it used to be. Second, template functions often produce crazy-looking error messages that are much harder to decipher than those of regular functions (we’ll see an example of this in the next lesson). Third, template functions can increase your compile time and code size, as a single template might be “realized” and recompiled in many files (there are ways to work around this one).

However, these drawbacks are fairly minor compared with the power and flexibility templates bring to your programming toolkit!

Note: The standard library already comes with a templated max() function (in the algorithm header), so you don’t have to write your own (unless you want to). If you do write your own, note the potential for naming conflicts if you use the statement “using namespace std;”, as the compiler will be unable to tell whether you want your version of max() or std::max().

In the rest of this chapter, we’ll continue to explore the topic of templates.

13.2 -- Function template instances
12.x -- Chapter 12 comprehensive quiz

103 comments to 13.1 — Function templates

  • Nirbhay

    Really enjoyed this lesson! :)

  • Atas

    Isn't max returning dangling references if we feed it rvalues?

    If not, why? I can't see a difference between this and the example in a previous lesson:

    • Passing 3 and 7 to a function that wants references causes 2 temporaries to be created. These temporaries live until the end of the expression that initiated the call. The temporaries live for the entirety of line 9.

      The reference would dangle if you kept it a reference.

      Since you're copying the reference before it starts dangling, there's no problem.

      • Atas

        Ohhh, subtle. I thought the temporaries die when their local scope ends. Thanks!

      • Atas

        A follow-up question, now that I had time to think about it: isn't it dangerous that you can assign the result of a function to a variable, but not to a reference, not even a const reference? The function's prototype doesn't seem to make it immediately obvious that you shouldn't do so. Would declaring

        be better in some contexts?

        • I wouldn't say so.

          If the function's declaration isn't obvious enough, add a comment. Binding references to a value returned by a non-member function is rare and should spark enough concern to check the documentation.

  • The numbers are divided by the number 3 from 1 to 100 using the Recursion
    الاعداد التي تقبل القسمة على3 من 1 الى100

  • The numbers that are divided into 3 are 1 to 100 using the self-call

  • Hello Alex,
    could i ask your help, i'am creating a database container class that uses a vector of users, where each user has a ID, name, i'am writing my own version of bisection search
    my problem is the bisection search function have to use getname() method when searching for name and use getID() when searching for ID

    so i would need 2 versions of bisection search function thus i tried to make it a template one version function and use overloading casting operator on the user class so when comparing an element of the user vector against the search Element i would just cast it to the type of the parameter the function is being called with static_cast<T1>(Vec[0])

    and it worked but i had to write a code that is ugly and does not make sense:

    - is the binary search function a good candid to be a template version function ?
    - if no, is there a better option than writing 2 function versions ?

    thanks a lot :)

    • Add a third parameter to @binarySearch to pass a comparison function.

      Then use @comp to compare the elements.

      • Hello nascardriver
        i don't know how to use std::function as i don't understand how it works yet, can it perform different operations
        for example my binary search is doing the following comparisons because i'am searching for bounds too (lower bound and upper bound)

        i don't understand can a one function perform multiple comparisons, for example should i have another input describing which comparison to perform ?
        also could you please give me an example of using std::function ...

        • (I forgot a parameter in my previous reply. I added it.)

          In that case, you can change @comp to return an int, indicating the relationship between two objects.

          Now you can use @comp like so

          @std::function is covered in lesson 7.8.

          • Ok thanks i understand it a little more now, i updated the binary function to

            as i did not want to create a user from search element as it would be incomplete (just id is correct or name or age) any one chosen to search and rest of the data would be invalid, but does it make sense to have a compare function like this:

            or should i better create a temp user from the search element and use it for my compare function as it makes more sense ?

            • You don't need a temp user and @User doesn't have to be complete at the declaration or definition of @binarySearch. The caller supplies the comparison function, so only the caller needs the complete type of @User. There will be no  copies of the users, because they're passed by reference.

  • lucieon

    I've seen template keyword being used in place of typename.
    For example:

    Is there any difference between the two?

    • What you've seen is probably "typename", not "template".
      "typename" and "class" are interchangeable in templates.
      If this isn't it, can you provide a link to an example of what you mean? The code you posted is syntactically incorrect.

Leave a Comment

Put all code inside code tags: [code]your code here[/code]