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, one with double parameters, and one with char parameters.


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

26 comments to 13.1 — Function templates

  • Danny

    using code blocks, this is what i’m getting in the debugger

    error: call of overloaded ‘max(int,int)’ is ambiguous

    can i get some info on this

    • Alex

      You’re probably having a naming conflict between your version of max and std::max. If you’re using “using namespace std;” get rid of it.

  • The Long

    Hi, Alex.
    1. I try your example code with a little different in main() (same definition):

    The compiler does not compile due to the different types of parameters. Of course we can use multiple type of parameter in the declaration of the Template function, but I remember that there is a thing called implicit type conversion in C++. Does it not work here? If not, why is that?
    2. In “using function template” part, you passed argument by reference in the template function, how can you pass by value in main() ? I mean r-value which have no address. That code does not seem to work in Visual Studio 2012 Ultimate.
    Thank you for your time.

    • Alex

      1) Implicit type conversion doesn’t work with template argument deduction. I’m not sure why that is. Maybe the matching rules would be too complex.
      2) Not by reference -- by const reference. Const references can bind to both l-values and r-values. If this doesn’t work in Visual Studio 2012, then I’m surprised.

  • C

    Hi everyone,

      I have a question about "const T& ". In pointer, it is used as &T for the address of variable T. Why T& here?

    Thank you

  • Deepanshu

    Hi Alex, can you please help me to find out how can I sort out the error in the following C++ code containing a template?

    The error I am getting is in function ‘int main()’:
    error: call of overloaded ‘swap(int&, int&)’ is ambiguous
    error: call of overloaded ‘swap(float&, float&)’ is ambiguous

    • Alex

      Your user defined function swap() is having a naming conflict with standard library function std::swap() because you did a “using namespace std;”. The compiler can’t tell whether you intend to call your own swap function or std::swap.

      This is precisely why using explicit namespace prefixes is better than using namespace std.

  • YKT

    Do u have plan to provide the "Multi-Threading or Concurrency" tutorial?

    Best Regards

  • kris

    double max(double dX, double dY)
        return (dX > dY) ? dX : dY;

    You did a couple of these examples before like this and never showed the meaning. what is it for?

  • mslade

    It seems like template functions can violate encapsulation. In your max() example, client code needs to know that it uses the > operator, and that operator>(the_type, the_type) needs to be defined for it to work.

    Is there a way around this or am I just wrong?

    • Alex

      Yes, the client code does need to know that it uses operator> and that operator needs to be defined for the function to work. This doesn’t violate encapsulation though, as the data of all the classes involved still stays protected from outside tampering.

  • Clarisse

    The person who writes n this blog must be really happy with happy feelings =)

  • Can you define these Template functions in seperate cpp files and have the definition in a .h file like normal functions?

    If i then use the GetArrayLength() function from my main.cpp, I get the following build errors:

    If I just define the function twice (once in my helper.cpp and once in my main.cpp), everything works as expected. Any idea what’s wrong here?

    • Slice

      I’m running Microsoft Visual Studio 2008 Professional Edition, Version 9.0.21022.8 RTM with .NET Framework, Version 3.5 SP1, and I can confirm that it still doesn’t allow you to split a template into the typical header and source file arrangement. In order to get templates to work in that environment, one must still code the entire template definition inside the header file :(.

      On the up side: my 1st linker error in the whole tutorial. W00!

      Oh, and great tutorial Alex (if you still read these). I even stopped reading the book I was reading on C++ about halfway through and totally moved onto this and even started doing some graphics work at the same time because the information presented here was so clear and concise albeit littered with “it’s” when they should have been “its” :P. I will go back and finish the book at some point just in case I missed anything, but in the mean time onward I go.

      • Darren

        By-the-way this behaviour is correct. Think of the template as being a hole in the function definition that won’t be filled until it is complied and linked with some usage of the function, i.e. in an executable; it won’t compile otherwise as the compiler has no idea of the size of the type that is going to be used. The template definition must therefore reside in the header file so that it is compiled with an executable’s source code when it is included. You can put template function declaration and template definition into separate files but have to include the file containing the definition at the bottom of the header file (technically the definition is then still in the header file). Typically the definition file has an ‘.inl’ extension to differentiate them from normal source files.

        Because you have to include the template function definition in the header file this can significantly increase the time taken to compile large projects that rely on templated functions. However, most programmers are not overly concerned with compile times.

  • karmeloz

    when we use the keyword “template”, we tell the compiler that what follows is going to be a list of template parameters.
    so why do we need the additional keyword typename (or class) for each parameter ? is the keyword typename redudantant
    or does it have a specific function? thanks, Karmeloz

  • Puneet

    Many people are not able to explain things in such a clear way.. This is really helpful.. Thanks…

  • Abhijit Yelegaonkar

Leave a Comment

Put C++ code inside [code][/code] tags to use the syntax highlighter