Template Specialization

Once we have a template class or function, we can create specialized versions of that template. These specializations allow us to provide a different implementation for a template, based on the exact template arguments received.

These different implementations can include behavioral changes, performance optimizations, and more.

Template specialization gives us a great deal of additional flexibility. It is also a common technique that is used to make our types compatible with functionality implemented in libraries, including the standard library. We’ll see an example of this later in the lesson

Function Template Specialization

In the following example, we have three types - Tree, Rock, and Monster. We’d like to create a generic algorithm that works with all these types - for example, to render them to the screen.

Given they have different types, we’d need to create a function template to support this:

1#include <iostream>
2
3struct Tree {
4  std::string Description{"Tree"};
5};
6
7struct Rock {
8  std::string Description{"Rock"};
9};
10
11struct Monster {
12  std::string Name{"Monster"};
13};
14
15template <typename T>
16void Render(T Object) {
17  std::cout << "Rendering a "
18    << Object.Description << '\n';
19}
20
21int main() {
22  Render(Tree{});
23  Render(Rock{});
24  Render(Monster{}); 
25}

Unfortunately, our Monster type is slightly different from the others. Rather than having a Description, its member variable is called Name. Accordingly, we get a compilation error when our template generates a function that tries to access a member that doesn’t exist when T is Monster:

1error C2039: 'Description': is not a member of 'Monster'

To get around this, we can specialize our function template such that, if its template argument is a Monster, the function it generates has a different implementation. It looks like this:

1#include <iostream>
2
Tree, Rock, and Monster Structs|Show
3struct Tree; struct Rock; struct Monster;
15
16// General Template
17template <typename T>
18void Render(T Object) {
19  std::cout << "Rendering a "
20    << Object.Description << '\n';
21}
22
23// Specialized Template
24template <>
25void Render<Monster>(Monster Object) {
26  std::cout << "Rendering a "
27    << Object.Name << '\n';
28}
29
30int main() {
31  Render(Tree{});
32  Render(Rock{});
33  Render(Monster{});
34}

1Rendering a Tree
2Rendering a Rock
3Rendering a Monster

1#include <iostream>
2
Tree, Rock, and Monster Structs|Show
3struct Tree; struct Rock; struct Monster;
15
16template <typename T>
17void Render(T Object) {
18  if constexpr (std::same_as<T, Monster>) {
19    std::cout << "Rendering a "
20      << Object.Name << '\n';
21  } else {
22    std::cout << "Rendering a "
23      << Object.Description << '\n';
24  }
25}
26
27int main() {
28  Render<Tree>(Tree{});
29  Render<Rock>(Rock{});
30  Render<Monster>(Monster{});
31}

1Rendering a Tree
2Rendering a Rock
3Rendering a Monster

Member Function Template Specialization

Specializing member function templates uses a very similar syntax to specializing free function templates. Our following example is very similar to the previous one, except we’ve moved the Render template within a Renderer class:

1#include <iostream>
2
Tree, Rock, and Monster Structs|Show
3struct Tree; struct Rock; struct Monster;
15
16class Renderer {
17 public:
18  // General template
19  template <typename T>
20  void Render(T Object) {
21    std::cout << "Rendering "
22      << Object.Description << '\n';
23  };
24
25  // Specialized template
26  template <>
27  void Render<Monster>(Monster Object) {
28    std::cout << "Rendering "
29      << Object.Name << '\n';
30  }
31};
32
33int main() {
34  Renderer A;
35
36  A.Render(Tree{});
37  A.Render(Rock{});
38  A.Render(Monster{});
39}

1Rendering A Tree
2Rendering A Rock
3Rendering A Monster

We also have the option of overloading a member function outside of the class declaration, if preferred. This is the most common technique in large projects, as it allows us to provide the overload alongside the type it is associated with.

For example, we can imagine Renderer being a core system in our project, whilst Monster is a type we want to make compatible with it via template specialization. In this scenario, we’d prefer the specialization be in the same files that define our Monster type. We can implement that as follows:

1// Monster.h
2#include <string>
3#include "Renderer.h"
4
5struct Monster {
6  std::string Name{"A Monster"};
7};
8
9template <>
10void Renderer::Render<Monster>(Monster Object) {
11  // Monster-specific rendering implementation
12}

Class Template Specialization

Class template specialization has the same use cases and syntax as the other forms of specialization we have seen. Below, we’ve replicated a similar pattern as above, except now our entire class is a template, rather than just a member function:

1#include <iostream>
2
Tree, Rock, and Monster Structs|Show
3struct Tree; struct Rock; struct Monster;
15
16// General Template
17template <typename T>
18class Renderable {
19 public:
20  void Render() {
21    std::cout << "Rendering "
22      << Object.Description << '\n';
23  };
24
25  T Object;
26};
27
28// Specialized Template
29template <>
30class Renderable<Monster> {
31 public:
32  void Render() {
33    std::cout << "Rendering " <<
34      Object.Name << '\n';
35  };
36
37  Monster Object;
38};
39
40int main() {
41  Renderable SomeTree{Tree{}};
42  SomeTree.Render();
43
44  Renderable SomeRock{Rock{}};
45  SomeRock.Render();
46
47  Renderable SomeMonster{Monster{}};
48  SomeMonster.Render();
49}

1Rendering A Tree
2Rendering A Rock
3Rendering A Monster

We can alternatively provide member functions for a specific instantiation of our class template, without providing a replacement for the entire class.

In the following example, we have also moved the general definition of Render outside the class body for clarity, but this is optional:

1#include <iostream>
2
Tree, Rock, and Monster Structs|Show
3struct Tree; struct Rock; struct Monster;
15
16template <typename T>
17class Renderable {
18 public:
19  void Render();
20  T Object;
21};
22
23// General implementation of Render
24template <typename T>
25void Renderable<T>::Render() {
26  std::cout << "Rendering "
27    << Object.Description << '\n';
28}
29
30// Specialized implementation of Render
31template <>
32void Renderable<Monster>::Render() {
33  std::cout << "Rendering " <<
34    Object.Name << '\n';
35}
36
37int main() {
38  Renderable SomeTree{Tree{}};
39  SomeTree.Render();
40
41  Renderable SomeRock{Rock{}};
42  SomeRock.Render();
43
44  Renderable SomeMonster{Monster{}};
45  SomeMonster.Render();
46}

1Rendering A Tree
2Rendering A Rock
3Rendering A Monster

Partial Specialization

Our previous examples of class template specialization specified the values of every argument in the template parameter list.

We can determine when this is the case because our parameter list will be empty:

1template <>
2void Renderable<Monster>::Render() {
3  // ...
4}

These were examples of full specialization. However, when we specialize a template, we don’t need to specify every template parameter. We can specify only a subset of them, using a technique called partial template specialization.

In this example, we’ve updated our Renderable class template to have two parameters - a typename and an int. Then, we’ve provided a partial specialization that specifies only one of those parameters.

As such, our specialization applies to any instantiation of our template that uses 1 as the Quantity argument, regardless of what is provided for the typename T:

1#include <iostream>
2
Tree, Rock, and Monster Structs|Show
3struct Tree; struct Rock; struct Monster;
15
16// General template
17template <typename T, int Quantity>
18class Renderable {
19 public:
20  void Render() {
21    std::cout << "Rendering " << Quantity << " "
22      << Object.Description << "s\n";
23  };
24
25  T Object;
26};
27
28// Specialization that is used if Quantity is 1
29template <typename T>
30class Renderable<T, 1> {
31 public:
32  void Render() {
33    std::cout << "Rendering a single "
34      << Object.Description << "\n";
35  };
36
37  T Object;
38};
39
40int main() {
41  Renderable<Tree, 1> OneTree{Tree{}};
42  OneTree.Render();
43  
44  Renderable<Rock, 1> OneRock{Rock{}};
45  OneRock.Render();
46  
47  Renderable<Tree, 10> SomeTrees{Tree{}};
48  SomeTrees.Render();
49}

1Rendering a single Tree
2Rendering a single Rock
3Rendering 10 Trees

In this example, we’ve partially specialized Renderable for any instantiation that uses Monster as the argument for T, regardless of what Quantity is used:

1#include <iostream>
2
Tree, Rock, and Monster Structs|Show
3struct Tree; struct Rock; struct Monster;
15
Renderable Class Template (Unchanged)|Show
16class Renderable {/*...*/};
27
28// Specialization that is used if T is Monster
29template <int Quantity>
30class Renderable<Monster, Quantity> {
31 public:
32  void Render() {
33    std::cout << "Rendering " << Quantity << " "
34      << Object.Name << "s\n";
35  };
36
37  Monster Object;
38};
39
40int main() {
41  Renderable<Tree, 10> Trees{Tree{}};
42  Trees.Render();
43
44  Renderable<Monster, 10> Monsters{Monster{}};
45  Monsters.Render();
46
47  Renderable<Monster, 500> Army{Monster{}};
48  Army.Render();
49}

1Rendering 10 Trees
2Rendering 10 Monsters
3Rendering 500 Monsters

Of course, our specialization could provide values for both arguments. This would be another example of a full specialization:

1template <>
2class Renderable<Monster, 1> {
3  // ...
4};

Templated Member Functions of Class Template

It’s not possible to specialize the template of a member function when the class itself is also a template. However, we can get equivalent behaviour by conventional function overloading.

Our following example has a member function called Render that accepts a Monster, and a template function that accepts any type.

Based on how overload resolution happens, which we cover in detail later in the chapter, the non-template function takes priority over the templated function. This gives us the same behaviour as if we had specialized the template function:

1#include <iostream>
2
Tree, Rock, and Monster Structs|Show
3struct Tree; struct Rock; struct Monster;
15
16template <int Quantity>
17class Renderer {
18 public:
19  template <typename T>
20  void Render(T Object) {
21    std::cout << "Rendering " << Quantity << " " 
22      << Object.Description << "s\n";
23  };
24
25  void Render(Monster Object) {
26    std::cout << "Rendering " << Quantity << " "
27      << Object.Name << "s\n";
28  };
29};
30
31int main() {
32  Renderer<10> A;
33
34  A.Render(Tree{});
35  A.Render(Rock{});
36  A.Render(Monster{});
37}

1Rendering 10 Trees
2Rendering 10 Rocks
3Rendering 10 Monsters

We cover overload resolution in more detail later in this chapter.

Below, we have moved the definition of both our template function and our member function outside of the class declaration, and included two additional examples:

1#include <iostream>
2
Tree, Rock, and Monster Structs|Show
3struct Tree; struct Rock; struct Monster;
15
16template <int Quantity>
17class Renderer {
18 public:
19  template <typename T>
20  void Render(T Object);
21
22  void Render(Monster Object);
23};
24
25// Generic implementation
26template <int Quantity>
27template <typename T>
28void Renderer<Quantity>::Render(T Object) {
29  std::cout << "Rendering " << Quantity << " " 
30    << Object.Description << "s\n";
31}
32
33// Specialisation for Quantity = 1
34template <>
35template <typename T>
36void Renderer<1>::Render(T Object) {
37  std::cout << "Rendering a single "  
38    << Object.Description << '\n';
39}
40
41// Overload for T = Monster
42template <int Quantity>
43void Renderer<Quantity>::Render(Monster Object) {
44  std::cout << "Rendering " << Quantity << " "
45    << Object.Name << "s\n";
46}
47
48// Specialization for Quantity = 1
49// And Overloaded for T = Monster
50template <>
51void Renderer<1>::Render(Monster Object) {
52  std::cout << "Rendering a single "  
53    << Object.Name << '\n';
54}
55
56int main() {
57  Renderer<10> A;
58  A.Render(Tree{});
59  A.Render(Rock{});
60  A.Render(Monster{});
61
62  Renderer<1> B;
63  B.Render(Tree{});
64  B.Render(Rock{});
65  B.Render(Monster{});
66}

1Rendering 10 Trees
2Rendering 10 Rocks
3Rendering 10 Monsters
4Rendering a single Tree
5Rendering a single Rock
6Rendering a single Monster

Template Specialization with Libraries

One of the main practical use cases for template specialization is to enable integration between different code bases. For example, we might want to use a library of code created by some other developer.

One way they might decide to enable this integration could involve the library developer providing templates, and us specializing those templates for our types.

For example, let’s imagine we’re using a library that does some processing of an object, and part of that process requires the object’s name.

The library author doesn’t know how to get that name, because it doesn’t know what types it will be dealing with. Therefore, they provide a templated function called GetName():

1// SomeLibrary.h
2#pragma once
3#include <iostream>
4
5namespace SomeLibrary{
6  template <typename T>
7  std::string GetName(T& Obj){
8    return Obj.GetName();
9  }
10
11  template <typename T>
12  void Process(T& Obj){
13    std::cout << "Processing " << GetName(Obj);
14
15    //...
16
17    std::cout << "\nDone!";
18  }
19}

In our code, for any type we want to be compatible with this library, we would specialize the GetName() function, telling the library how to get our objects’ names:

1// Player.h
2#pragma once
3#include <string>
4#include "SomeLibrary.h"
5
6struct Player {
7  std::string Name;
8};
9
10namespace SomeLibrary {
11  template <>
12  std::string GetName<Player>(Player& P) {
13    return P.Name;
14  }
15}

Now, our objects can work elegantly with the library, without the library knowing anything about our code:

1#include <SomeLibrary.h>
2#include "Player.h"
3
4int main() {
5  Player PlayerOne{"Anna"};
6  SomeLibrary::Process(PlayerOne);
7}

1Processing Anna
2Done!

The standard library also uses this approach. For example:

• to make our type compatible with string interpolation utilities like std::format() and std::print(), we’d need to specialise the std::formatter template
• to make our type compatible with hash-based containers like std::set and std::map, we’d need to specialise the std::hash template

We’ll introduce both of these topics in detail later in the course.

Summary

This lesson covers template specialization in C++, a technique that allows creating specialized versions of function and class templates for specific types. Key takeaways include:

• Function, member function, and class templates can be specialized to provide different implementations based on template arguments
• Full specialization specifies values for all template parameters, while partial specialization specifies only a subset
• Specialization is useful for integrating with libraries and making user-defined types compatible with library functionality
• The standard library uses specialization for features like string interpolation and hash-based containers
• Specialization provides flexibility and optimization opportunities in generic programming

Next Lesson

Understanding Overload Resolution

Learn how the compiler decides which function to call based on the arguments we provide.

ContinueView Course