Using Type Traits with Template Specialization

Yes, you can use type traits to conditionally specialize a class template based on the properties of the template type. This is known as partial template specialization. Here's an example:

1#include <iostream>
2#include <type_traits>
3
4template <typename T, typename Enable = void>
5class MyClass {
6public:
7  void print() {
8    std::cout << "General case\n";
9  }
10};
11
12template <typename T>
13class MyClass<T, std::enable_if_t<
14  std::is_integral_v<T>>> {
15public:
16  void print() {
17    std::cout << "Specialization for"
18      " integral types\n";
19  }
20};
21
22template <typename T>
23class MyClass<T, std::enable_if_t<
24  std::is_floating_point_v<T>>> {
25public:
26  void print() {
27    std::cout << "Specialization for"
28      " floating-point types\n";
29  }
30};
31
32int main() {
33  MyClass<void> generalObj;
34  generalObj.print();
35
36  MyClass<int> intObj;
37  intObj.print();
38
39  MyClass<double> doubleObj;
40  doubleObj.print();
41}

1General case
2Specialization for integral types
3Specialization for floating-point types

In this example, we have a class template MyClass with two template parameters: T and Enable. The Enable parameter defaults to void and is used for enabling partial specialization based on type traits.

We define three different specializations of MyClass:

1. The general case: This is the default specialization that is used when no other specialization matches. It prints "General case".
2. Specialization for integral types: This specialization is enabled when T is an integral type, using std::enable_if_t and std::is_integral_v. It prints "Specialization for integral types".
3. Specialization for floating-point types: This specialization is enabled when T is a floating-point type, using std::enable_if_t and std::is_floating_point_v. It prints "Specialization for floating-point types".

When instantiating MyClass with different types, the appropriate specialization is selected based on the type traits. In the example, MyClass<void> uses the general case, MyClass<int> uses the specialization for integral types, and MyClass<double> uses the specialization for floating-point types.

By using type traits with partial template specialization, you can create class templates that adapt their behavior and implementation based on the properties of the template type. This allows for more fine-grained control and optimization based on the specific characteristics of the types used.