Template Specialization

Once we have a template class or function, we have the ability to create specialized versions of that template. These specializations allow us to provide a different implementation for a template for a given set of template arguments.

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

Template specialization also allows us to integrate third-party libraries or other code that requires specific interfaces or behaviors, without modifying our own code. We’ll see an example of this later in the lesson

Once we have a template class or function, we have the ability to create specialized versions of that template. These specializations allow us to provide a different implementation for a template for a given set of template arguments.

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

Template specialization also allows us to integrate third-party libraries or other code that requires specific interfaces or behaviors, without modifying our own code. We’ll see an example of this later in the lesson

Class Template Specialization

Let's imagine we have a simple template class that holds another object. The type of that other object is a template type:

1template <typename T>
2class ObjectHolder {
3public:
4  ObjectHolder(T Object) : Object{Object}{}
5  T Object;
6};
7

To create a specialization of this template to work with int objects, the syntax would look like this:

1template <>
2class ObjectHolder<int> {
3public:
4  ObjectHolder(int Object) : Object{Object}{
5    std::cout << "Oh great, an integer\n";
6  }
7
8  int Object;
9};
10

To summarise, we maintain the template syntax above the class, even if it no longer has any parameters.

We then specify the specialized type between chevrons < and > after our class name.

Then, anywhere in our class where we previously used our template type, we now use our known, specialized type - int, in this case.

Now, when we instantiate this template with an int, the specialized template will be used:

1#include <iostream>
2
3template <typename T>
4class ObjectHolder {
5public:
6  ObjectHolder(T Object) : Object{Object}{}
7  T Object;
8};
9
10template <>
11class ObjectHolder<int> {
12public:
13  ObjectHolder(int Object) : Object{Object}{
14    std::cout << "Oh great, an integer: ";
15  }
16
17  int Object;
18};
19
20int main(){
21  ObjectHolder FloatContainer{0.1f};
22  std::cout << FloatContainer.Object << '\n';
23
24  ObjectHolder DoubleContainer{0.5};
25  std::cout << DoubleContainer.Object << '\n';
26
27  ObjectHolder IntContainer{1};
28  std::cout << IntContainer.Object << '\n';
29}
30

10.1
20.5
3Oh great, an integer: 1
4

A template can have many specializations as we need:

1template <typename T>
2class ObjectHolder {};
3
4template <>
5class ObjectHolder<int> {};
6
7template <>
8class ObjectHolder<float> {};
9

However, before we go too far down that route, I’d recommend finishing the remaining lessons in this chapter.

They cover type traits and concepts, which give us lots of additional options, which may include better solutions to our specific use cases than lots of specialized templates.

Partial Class Template Specialization

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.

Let's imagine we have the following class, which has two template parameters:

1template <typename TFirst, typename TSecond>
2class SomeClass {};
3

To partially specialize this template for when the first type is an int, the syntax looks like this:

1template <typename TSecond>
2class SomeClass<int, TSecond> {};
3

This is similar to our previous example. Firstly, we removed the template parameter(s) we’re using in our specialization get removed from the template list.

We then specialized the class in the normal way using the < and > syntax, mixing specialization parameters and template parameters as needed.

In the following example, we update our earlier ObjectHolder class to instead store a std::array of objects. The size of the array is specified as a second, non-type template parameter:

1#include <array>
2
3template <typename T, size_t Size>
4class ObjectHolder {
5public:
6  ObjectHolder() : Array{
7    std::array<T, Size>{}}{}
8
9  std::array<T, Size> Array;
10};
11

We can partially specialize this class template, such that we provide a specific implementation when the type is int, but the Size remains a template parameter:

1#include <iostream>
2#include <array>
3
4template <typename T, size_t Size>
5class ObjectHolder {
6public:
7  ObjectHolder() : Array{
8    std::array<T, Size>{}}{}
9
10  std::array<T, Size> Array;
11};
12
13template <size_t Size>
14class ObjectHolder<int, Size> {
15public:
16  ObjectHolder() : Array{
17    std::array<int, Size>{}}{
18    std::cout << "Oh great, more integers: ";
19  }
20
21  std::array<int, Size> Array;
22};
23
24int main(){
25  ObjectHolder<float, 1> Floats;
26  std::cout << Floats.Array.size() << '\n';
27
28  ObjectHolder<double, 3> Doubles;
29  std::cout << Doubles.Array.size() << '\n';
30
31  ObjectHolder<int, 5> Ints;
32  std::cout << Ints.Array.size() << '\n';
33}
34

11
23
3Oh great, more integers 5
4

Function Template Specialization

We can also specialize function templates, using similar syntax:

1#include <iostream>
2
3template <typename T>
4auto Subtract(T x, T y){
5  std::cout << "Unspecialized\n";
6  return x - y;
7}
8
9template <>
10auto Subtract<float>(float x, float y){
11  std::cout << "Specialized - float\n";
12  return x - y;
13}
14
15template <>
16auto Subtract<double>(double x, double y){
17  std::cout << "Specialized - double\n";
18  return x - y;
19}
20
21int main(){
22  Subtract(2, 1); // int, int
23  Subtract(2.0f, 1.0f); // float, float
24  Subtract(2.0, 1.0); // double, double
25}
26

1Unspecialized
2Specialized - float
3Specialized - double
4

When a template function has multiple template parameters, the syntax looks like this:

1#include <iostream>
2
3template <typename TFirst, typename TSecond>
4auto Subtract(TFirst x, TSecond y){
5  std::cout << "Unspecialized\n";
6  return x - y;
7}
8
9template <>
10auto Subtract<float, double>(float x, double y){
11  std::cout << "Specialized - float, double\n";
12  return x - y;
13}
14
15template <>
16auto Subtract<int, double>(int x, double y){
17  std::cout << "Specialized - int, double\n";
18  return x - y;
19}
20
21int main(){
22  Subtract(2.0f, 1.0f); // float, float
23  Subtract(2.0, 1.0); // double, double
24  Subtract(2.0, 1.0f); // double, float
25  Subtract(2.0f, 1.0); // float, double
26  Subtract(2.0f, 1.0); // int, double
27}
28

1Unspecialized
2Unspecialized
3Unspecialized
4Specialized - float, double
5Specialized - int, double
6

Partial Function Template Specialization

Function templates do not support partial specialization, but any use case where we might want such a feature is covered by static overloading instead.

Our beginner course introduced static overloading of regular functions, but the exact same concepts apply to template functions

Static Overloading in C++

See how we can create different versions of functions by using different parameter types

When we make a function call, the compiler will first check if any regular function can serve that call. If no valid candidate is found, the compiler will then search for suitable template functions. When we don’t explicitly state the template we want our function call to use with the < and > syntax, the compiler will deduce the template to use based on this process:

• Prioritise non-template functions over template functions
• Prioritise template functions with fewer template parameters over those with more
• Prioritise specialized template functions over unspecialized template functions

The following code example demonstrates these behaviors:

1#include <iostream>
2
3void Func(double x, double y){
4  std::cout << "Regular Function Call\n";
5}
6
7template <typename T>
8void Func(double x, T y){
9  std::cout <<
10  "Template A: One Param - double, T\n";
11}
12
13template <typename T>
14void Func(T x, double y){
15  std::cout <<
16  "Template B: One Param - T, double\n";
17}
18
19template <>
20void Func<int, int>(int x, int y){
21  std::cout <<
22  "Template C: Two Params (Specialized)\n";
23}
24
25template <typename TFirst, typename TSecond>
26void Func(TFirst x, TSecond y){
27  std::cout << "Template D: Two Params\n";
28}
29
30int main(){
31  std::cout << "Template Argument Deduction\n";
32  Func(1.0, 2.0);   // Regular function call
33  Func(1.0, 2.0f);  // One-parameter template
34  Func(1.0f, 2.0);  // One-parameter template
35  Func(1, 2);       // Two-parameter specialized
36  Func(1.0f, 2.0f); // Two-parameter template
37
38  std::cout << "\nExplicit Calls\n";
39   // Two-parameter template
40  Func<double, double>(2.0, 1.0);
41
42  // Two-parameter specialized template
43  Func<int, int>(2.0, 1.0); 
44}
45

1Template Argument Deduction
2Regular Function Call
3Template A: One Param - double, T
4Template B: One Param - T, double
5Template C: Two Params (Specialized)
6Template D: Two Params
7
8Explicit Calls
9Template C: Two Params
10Template D: Two Params (Specialized)
11

Note, when overloading template functions, the same rules apply with regard to ambiguity. If the compiler has two viable candidates with the same priority, it will throw an error.

The following example shows this, as there are two function templates that can handle our function call. Both functions have the same priority (ie, they are unspecialized templates with the same number of template arguments), so the compiler is unclear on which template it should use::

1template <typename T>
2auto Subtract(double x, T y){
3  return x - y;
4}
5
6template <typename T>
7auto Subtract(T x, double y){
8  return x - y;
9}
10
11int main(){
12  Subtract(2.0, 1.0);
13}
14

1'Subtract': ambiguous call to overloaded function
2could be 'auto Subtract<double>(T,double)'
3or       'auto Subtract<double>(double,T)'
4while trying to match the argument list '(double, double)'
5

Class Method Specialization

Class methods can also be templates:

1class Logging {
2public:
3  template <typename T>
4  static void Log(T Object){
5    std::cout << Object << '\n';
6  }
7};
8

When we want to provide a specialization for a class method, we should do it outside of the class declaration. To provide a specialization for the above method when using an int, our implementation would look something like this:

1#include <iostream>
2
3class Logging {
4public:
5  template <typename T>
6  static void Log(T Object){
7    std::cout << Object << '\n';
8  }
9};
10
11template <>
12void Logging::Log<int>(int Object){
13  std::cout << "Another int: ";
14  std::cout << Object << '\n';
15}
16
17int main(){
18  Logging::Log(0.5);
19  Logging::Log(2.5f);
20  Logging::Log(5);
21}
22

10.5
22.5
3Another int: 5
4

Template Specialization with Libraries

A common use case for template specialization comes up when we’re integrating third-party libraries into our projects. For example, later in this course, we’ll use libraries that allow us to convert our objects into data formats that let them be saved on our hard drive, or transmitted over the internet.

Inherently, a library made by someone else is not going to know about the custom types we’re using in our application, so they’re likely to make use of template classes and functions.

Below, we create a library that has a templated process function, that we can imagine does some work with our objects.

1// SomeLibrary.h
2#pragma once
3#include <iostream>
4
5namespace SomeLibrary{
6  template <typename T>
7  void Process(T Object){
8    std::cout << "Processing "
9      << Object.GetDescription();
10
11    // ...do work
12    std::cout << "\nDone!";
13  }
14}
15

Being a templated function, we can call it with an instance of our custom type:

1// main.cpp
2#include <SomeLibrary.h>
3#include "Character.h"
4
5int main(){
6  Character Player;
7  SomeLibrary::Process(Player);
8}
9

However, our type is not yet compatible with the library, so we’ll get an error:

1'GetDescription': is not a member of 'Character'
2

When using (or writing) a library, there are three main ways we can allow custom types to be compatible.

Option 1 - Class Requirements

The first is to simply require these types to implement certain methods.

In this case, the library can document that, for any type to be compatible, it needs to implement a GetDescription() method. That method must return something that can be streamed to the terminal:

1// Character.h
2#pragma once
3
4class Character {
5public:
6  std::string GetDescription() const{
7    return "a Character object";
8  }
9
10  // ...
11};
12

This approach is the most common, but it does have some problems. First, it is modifying the public interface of our class in a way that we probably don’t want. Later in the course, we’ll see a way to eliminate this drawback using the friend keyword, but even then it will still require us to modify our class.

Another problem is that it’s just not clear from this code why the GetDescription() method exists, or that it is there for compatibility with an external library. The library is not referenced anywhere in the class.

If we later remove or replace the library, we’ll not get any compiler feedback to tell us we can now also remove methods like this from our classes. Inevitably, this leads to a lot of useless code clogging up our project.

Option 2 - Inheritance

Another option libraries can adopt is to provide their own class, which implements all the requirements. Then, for any class to be compatible with the library, it just needs to inherit from that library class:

1// Character.h
2#pragma once
3#include <SomeLibrary.h>
4
5class Character : public SomeLibrary::Object {
6  // ...
7};
8

This approach makes the dependency clear, but it has some problems. Quite often, the information the library needs to accomplish its task will be stored in the derived class, thereby not directly accessible to the base class.

As such, this approach generally requires us to write some additional code to call methods on the base class, depending on what the library requires.

Option 3 - Specialization

Finally, the third option is to use template specialization. Any time the library needs to retrieve information from an object of a templated type, it can separate that retrieval into a standalone template function, such as the SomeLibrary::GetDescription example below:

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

Now, for our type to be compatible with the library, it just provides a specialization for that template function:

1// Character.h
2#pragma once
3
4class Character {
5  // ...
6};
7
8namespace SomeLibrary{
9  template <>
10  std::string GetDescription<Character>
11  (const Character& Object){
12    return "a Character object";
13  }
14}
15

This solves the problem in a way that is explicit about why the code exists, and also doesn’t require any modification to our class.

1Processing a Character object
2Done!
3

Similarly, if we ever remove or replace the library, or this requirement ever changes, the compiler will throw a helpful error. This alerts us to an area where we may need to make changes, or perhaps an area where we can just delete some code that is no longer necessary, keeping our project clean:

1'std::string SomeLibrary::GetDescription<Character>(const Character &)'
2is not a specialization of a function template
3