How can I specialize a class template for specific types?

Question

Ryan McCombe · Accepted Answer

Class template specialization allows you to provide a custom implementation of a template for specific types.

This can be useful when you want to optimize for certain types or handle them differently. There are two types of specialization: full specialization and partial specialization.

Full Specialization

Full specialization is used when you want to provide a completely different implementation for a specific type. Here's an example:

1#include <iostream>
2#include <string>
3
4// Primary template
5template <typename T>
6class Container {
7 public:
8  void Store(T value) {
9    std::cout << "Storing generic value: "
10      << value << '\n';
11  }
12};
13
14// Full specialization for int
15template <>
16class Container<int> {
17 public:
18  void Store(int value) {
19    std::cout << "Storing int value: "
20      << value << '\n';
21  }
22};
23
24// Full specialization for std::string
25template <>
26class Container<std::string> {
27 public:
28  void Store(const std::string& value) {
29    std::cout << "Storing string value: "
30      << value << '\n';
31  }
32};
33
34int main() {
35  Container<double> doubleContainer;
36  Container<int> intContainer;
37  Container<std::string> stringContainer;
38
39  doubleContainer.Store(3.14);
40  intContainer.Store(42);
41  stringContainer.Store("Hello, World!");
42}

1Storing generic value: 3.14
2Storing int value: 42
3Storing string value: Hello, World!

In this example, we have a primary template and two full specializations for int and std::string.

Partial Specialization

Partial specialization is used when you want to specialize a template for a subset of possible types. It's particularly useful for templates with multiple parameters. Here's an example:

1#include <iostream>
2#include <vector>
3#include <list>
4
5// Primary template
6template <typename T, typename Container>
7class DataManager {
8 public:
9  void Process() {
10    std::cout << "Processing generic data\n";
11  }
12};
13
14// Partial specialization for vector containers
15template <typename T>
16class DataManager<T, std::vector<T>> {
17 public:
18  void Process() {
19    std::cout << "Processing vector data\n";
20  }
21};
22
23// Partial specialization for pointers
24template <typename T>
25class DataManager<T*, std::vector<T*>> {
26 public:
27  void Process() {
28    std::cout << "Processing vector of pointers\n";
29  }
30};
31
32int main() {
33  DataManager<int, std::vector<int>>
34    vectorManager;
35  DataManager<int*, std::vector<int*>>
36    pointerVectorManager;
37  DataManager<double, std::list<double>>
38    listManager;
39
40  vectorManager.Process();
41  pointerVectorManager.Process();
42  listManager.Process();
43}

1Processing vector data
2Processing vector of pointers
3Processing generic data

In this example, we have a primary template and two partial specializations: one for vectors and another for vectors of pointers.

Specialization allows you to write more efficient or appropriate code for specific types while maintaining a general implementation for others. It's a powerful feature of C++ templates that enables you to optimize performance and provide type-specific behavior when needed.

Class Templates

Specializing Class Templates

Full Specialization

Partial Specialization

Class Templates

Professional C++

Questions & Answers