Class Templates

In the previous section, we introduced the std::pair type, which allows us to create containers for storing two pieces of data, of any type.

We provide the two data types we will need to store within chevrons, < and >:

1std::pair<int, float> MyPair;

We can then access the values stored in those slots using class variables called first and second:

1#include <utility>
2#include <iostream>
3
4int main() {
5  std::pair<int, float> MyPair{42, 9.8f};
6
7  std::cout << "First " << MyPair.first
8    << "\nSecond " << MyPair.second;
9}

1First: 42
2Second: 9.8

std::pair is an example of a template and, in this lesson, we’ll see how we can create our own templates to give similar flexibility.

Why do we need Templates?

If we wanted to make a container like std::pair in a world without templates, we would need to define the types of our first and second member variables. For example, we could create a container for storing an int and a float like this:

1class Pair {
2 public:
3  int first;
4  float second;
5};

Obviously, this is not especially flexible. If we wanted to create containers where our first and second members have a different type, we’d need to create a different class.

Worse, we may not even know what types we need to support. For example, the developers who wrote the code for std::pair couldn't have known what user-defined types we might create in our projects, but thanks to templates, their code can support those types:

1#include <iostream>
2
3struct Player {
4  std::string Name{"Anna"};
5};
6
7int main() {
8  std::pair<Player, int> MyPair{Player{}, 42};
9
10  std::cout << "Name: " << MyPair.first.Name;
11}

1Name: Anna

What Are Templates?

There are many different forms of templates, and we’ll cover them all in this chapter. In this lesson, we’ll start with class templates, which std::pair is an example of. We can think of a class template as being a recipe for creating classes.

Just as a class can be instantiated to create an object, a class template can be instantiated to create a class.

These classes are created at compile time. We provide a class template, and the compiler can use that template to create classes as needed.

Templates can have parameters, just like a function. Within our template body, those parameters can be used to customise how each class is created on each instantiation of the template.

For example, within the std::pair class template, the data type the first and second class members are each determined by parameters. And, just like a function, we provide arguments to those parameters when we instantiate our template.

Whilst function arguments are provided between a ( and ), template arguments are provided within angled brackets, < and >. Below, we instantiate the std::pair template, providing int as the first template argument, and bool as the second:

1std::pair<int, bool>

As we’ve seen, this will cause the compiler to instantiate a class that has a first member of type int and a second member of type bool.

Deduplication

The compiler is smart enough to reuse previously created classes, where appropriate. For example, if std::pair<int, bool> appears multiple times in our code, a class will only be created once. On any subsequent encounters of the same template, with the same argument list, the compiler will reuse the class it created previously.

We don’t need a new class for each new object. As we’ve seen before, a class can be used to create many objects, and that includes classes that were created by class templates. In the following example, we use our template three times, but two of those invocations use the same arguments, in the same order:

1std::pair<int, bool> MyPairA { 4, true };
2std::pair<int, bool> MyPairB { 41, false };
3std::pair<float, int> MyPairC { 1.3f, 2 };

After running this code, we will have two classes: a class designed to store an int and a bool, and a class designed to store a float and an int. We will have two objects that are instances of the first class, and one object that is an instance of the second class.

Declaring Template Parameters

The syntax for declaring a class template is very similar to declaring a class. The main addition is we provide a list or parameters to be used within the template.

We do this using the template keyword, following by the parameter list between a set of angled brackets < and >. As with a function, each parameter will have a type, and name with which we will refer to that parameter within our template.

Below, we define a class template called Pair. It has a single non-type template parameter of type int, which we've named SomeInt:

1template <int SomeInt>
2class Pair {
3 public:
4  // ...
5};

With templates, the most common type of parameter we’ll need is the name of some other type. Below, we’ve changed our argument list to receive a typename, which we’ve called SomeType:

1template <typename SomeType>
2class Pair {
3 public:
4  // ...
5};

For simple templates, it’s very common for the name of the type to simply be called T:

1template <typename T>
2class Pair {
3 public:
4  // ...
5};

Using Template Parameters

Once we’ve established our template parameters, we can then simply use them within our class template. Our parameter T is a typename, so we can use it anywhere a typename would be expected.

Below, we’ve used T as the type of our first and second member variables. Because we only have a single template argument, first and second must share the same type. We’ll expand this to multiple parameters later in this section:

1template <typename T>
2class Pair {
3 public:
4  T first;
5  T second;
6};

We can also use this T typename as the return and parameter types of class functions, for example. The following shows an alternative implementation of Pair where we keep first and second private, forcing the use of getters and setters:

1#include <iostream>;
2
3template <typename T>
4class Pair {
5 public:
6  Pair(T first, T second) :
7    mFirst(first), mSecond{second} {}
8
9  T GetFirst() const { return mFirst; }
10  void SetFirst(T first) { mFirst = first; }
11
12  T GetSecond() const { return mSecond; }
13  void SetSecond(T second) { mSecond = second; }
14
15 private:
16  T mFirst;
17  T mSecond;
18};
19
20int main() {
21  Pair<int> MyPair{42, 5};
22
23  std::cout << "First: " << MyPair.GetFirst()
24    << "\nSecond: " << MyPair.GetSecond();
25}

1First: 42
2Second: 5

The fact that we’re using a template type does not restrict us from using regular types as well. We can mix them as needed. In the following example, second is always an int:

1#include <iostream>;
2
3template <typename T>
4class Pair {
5 public:
6  Pair(T first, int second) :
7    mFirst(first), mSecond{second} {}
8
9  T GetFirst() const { return mFirst; }
10  void SetFirst(T first) { mFirst = first; }
11
12  int GetSecond() const { return mSecond; }
13  void SetSecond(int second) { mSecond = second; }
14
15 private:
16  T mFirst;
17  int mSecond;
18};
19
20int main() {
21  Pair<float> MyPair{9.8f, 5};
22
23  std::cout << "First: " << MyPair.GetFirst()
24    << "\nSecond: " << MyPair.GetSecond();
25}

1First: 9.8
2Second: 5

Class Template Argument Deduction (CTAD)

When working with templates, it is not always necessary to explicitly provide the template arguments. For example, when we’re initializing an object, the compiler can sometimes infer from the constructor arguments what the template arguments would be.

The most common scenario where this can be used is when we’re providing initial values for a class. In the following example, we’re using the Pair template to create a Pair<int> class, and then immediately instantiating that class to create an object called MyPair:

Pair Class Template|Show
1class Pair {/*...*/};
8
9int main() {
10  Pair<int> MyPair{42, 5};
11}

Because we’re providing initial values for our class, the compiler can automatically deduce what type of class we need. Our values 42 and 5 are int, so the compiler can infer we want to create a Pair<int>. As such, we can remove the template argument:

Pair Class Template|Show
1class Pair {/*...*/};
8
9int main() {
10  Pair MyPair{42, 5};
11}

This is referred to as Class Template Argument Deduction or CTAD. However, just because this is possible, it doesn’t mean it should always be used. It broadly has the same benefits and drawbacks as any other form of automatic type deduction, such as the auto keyword.

Automatic Type Deduction using auto

This lesson covers how we can ask the compiler to infer what types we are using through the auto keyword

Different developers and teams are likely to have their own rules on when CTAD, and any other form of type deduction should be used.

Multiple Parameters

As with functions, our templates can accept as many parameters as we need We separate multiple parameters with a comma ,

Below, we expand our Pair class to accept two type name parameters, which we’ve called T1 and T2. We then set the data type of first to be T1, whilst second will have a type of T2. This replicates the behaviour of the std::pair type:

1template <typename T1, typename T2>
2class Pair {
3 public:
4  T1 first;
5  T2 second;
6};

Similarly, we provide multiple arguments to our template by separating them with a comma. Below, we create a class from our Pair template that sets T1 to bool and T2 to int. We then instantiate that class to create an object called MyPair:

Pair Class Template|Show
1class Pair {/*...*/};
8
9int main() {
10  Pair<bool, int> MyPair;
11}

Nested Parameters

Previously, we’ve seen how a function argument can be an invocation of another function:

1Add(1, Add(2, 3));

We can do the exact same thing when using template arguments:

1Pair<bool, Pair<int, float>>

An invocation like this will create a pair class whose first type is bool, and whose second type is another instantiation of the Pair template. Specifically, it will be a pair whose first type is int, and whose second type is float:

Pair Class Template|Show
1class Pair {/*...*/};
8
9int main() {
10  Pair<bool, Pair<int, float>> MyPair;
11  MyPair.first = true;
12  MyPair.second.first = 42;
13  MyPair.second.second = 9.8;
14}

Remember, if a type becomes complex or difficult to understand, we can create an alias for it using a more descriptive name:

1using HelpfulName = Pair<bool, Pair<int, float>>;

Default Parameters

Just like function parameters can have default values, so too can template parameters. Below, we default both parameters to be int:

1#include <string>
2
3template <typename T1 = int, typename T2 = int>
4class Pair {
5 public:
6  T1 first;
7  T2 second;
8};
9
10int main() {
11  // Creates a Pair<int, int>
12  Pair<> A;
13  A.first = 42;
14  A.second = 100;
15
16  // Creates a Pair<std::string, int>
17  Pair<std::string> B;
18  B.first = "Hello World";
19  B.second = 100;
20}

From C++17, if all template parameters have default arguments and we're not specifying any explicit template arguments, we can omit the <> if preferred:

Pair Class Template|Show
1class Pair {/*...*/};
8
9int main() {
10  // Creates a Pair<int, int>
11  Pair A;
12  A.first = 42;
13  A.second = 100;
14}

Non-Typename Parameters

In most practical use cases, our template parameters will be type names, but not always. It’s valid to use any of the other data types as a template parameter, such as integers, booleans and even user-defined types.

Below, we create a class template that uses an int parameter, which we’ve called SomeInt:

1#include <iostream>
2
3template <int SomeInt>
4class Resource {
5 public:
6  int Value{SomeInt};
7};
8
9int main() {
10  Resource<42> A;
11  std::cout << "Value: " << A.Value;
12}

1Value: 42

Like a function argument, a template argument does not need to be a static value - it can be any expression that results in a value. However, given that templates are evaluated at compile time, the expression we use as a template argument will also be evaluated at compile time.

This means we can use compile time constants as template arguments, but not runtime expressions such as the value returned from a regular function:

1#include <iostream>
2
Resource Class Template|Show
3class Resource {/*...*/};
9
10int GetInt() { return 42; }
11
12int main() {
13  constexpr int SomeConst{5};
14
15  // This is fine
16  Resource<SomeConst> A;  
17
18  // This is not
19  Resource<GetInt()> B;
20}

1error C2975: 'SomeInt': invalid template argument for 'Resource', expected compile-time constant expression

Later in this chapter, we’ll introduce more scenarios where the constexpr specifier can be applied, expanding what we can do at compile time to include function calls and custom object creation.

Template Parameters vs Class Members

Note that a class template parameter is not the same as a class member. In the previous examples, we’ve been saving it as a class member (which we called Value) but we don’t need to.

When our class template is instantiated to create a class, everywhere we’ve used the identifier SomeInt within that template gets replaced with the value provided as the template argument.

In the following example, once the compiler has completed, we have two classes, both based on the Resource template. In one class, the body of the Log() function is std::cout << 42 whilst in the other, it’s std::cout << 5:

1#include <iostream>
2
3template <int SomeInt>
4class Resource {
5 public:
6  void Log() {
7    std::cout << SomeInt;
8  }
9};
10
11int main() {
12  Resource<42> A;
13  A.Log();
14
15  std::cout << ", ";
16  Resource<5> B;
17  B.Log();
18}

142, 5

Using Template Types

When we have a class template, we should remember that the name of the template is not, by itself, the name of a type.

Below, we’re trying to create a Resource class, which has a class member that we want to be an instance of some Pair class. This won’t work:

Pair Class Template|Show
1class Pair {/*...*/};
8
9class Resource {
10 public:
11  Pair SomePair;
12};

1error C2955: 'Pair': use of class template requires template argument list

This is because Pair is not a type - it is a class template. We could use Pair<int, float> here for example, because that is a type.

If we know the exact type of Pair we are expecting, we can simply provide the template arguments in this way. Below, we update our Resource to clarify that it’s member will be an instance of the Pair<int, float> type:

Pair Class Template|Show
1class Pair {/*...*/};
8
9class Resource {
10 public:
11  Pair<int, float> SomePair;
12};

However, we often won’t know exactly what instance of a template we’re supporting. As a result, when we have classes or functions that work with template types, those will often also need to be templates themselves.

We cover function templates later in the chapter. Below, we update our Resource class to be a class template, meaning it can be used to create classes for storing any type of Pair:

1#include <iostream>
2
Pair Class Template|Show
3class Pair {/*...*/};
10
11template <typename T1, typename T2>
12class Resource {
13 public:
14  Pair<T1, T2> SomePair;
15};
16
17int main() {
18  Resource<float, int> SomeResource{
19    Pair<float, int>{9.8f, 42}
20  };
21
22  std::cout << "Second: "
23    << SomeResource.SomePair.second;
24}

1Second: 42

Pair Class Template|Show
1class Pair {/*...*/};
8
Resource Class Template|Show
9class Resource {/*...*/};
15
16int main() {
17  Resource SomeResource{Pair{9.8, 42}};
18}

Pair Class Template|Show
1class Pair {/*...*/};
8
9template <typename T>
10class Resource {
11 public:
12  T SomePair;
13};
14
15int main() {
16  Resource SomeResource{Pair{9.8, 42}};
17}

1template <typename T>
2class Resource {
3 public:
4  T SomePair;
5};
6
7int main() {
8  Resource SomeResource{"Hello there"};
9}

1template <typename T1, typename T2>
2struct Pair {
3  T1 first;
4  T2 second;
5};

Summary

In this lesson, we introduced templates in C++, starting with class templates. The key points to remember are:

• Templates are like recipes for creating other constructs. For example, a class template can be used to create classes
• Why class templates such as std::pair are useful, and how they can give us more flexibility than what we could get through a single class
• How to declare class templates with the template keyword and a list of template parameters.
• How to use template parameters within class templates to define member types and functions.
• When instantiating a template, the compiler can sometimes deduce what arguments are required using Class Template Argument Deduction (CTAD).
• Much like functions, templates can have multiple parameters, default parameters and template arguments can themselves be invocations of other templates.

Next Lesson

Templates and Header Files

Learn how to separate class templates into declarations and definitions while avoiding common linker errors

ContinueView Course