Using Type Traits with Class Templates

Yes, you can use type traits in combination with SFINAE (Substitution Failure Is Not An Error) to conditionally enable or disable member functions in a class template based on the properties of the template type. Here's an example:

1#include <iostream>
2#include <type_traits>
3
4template <typename T>
5class MyClass {
6public:
7  // Enable this function only if T
8  // is an arithmetic type
9  template <typename U = T,
10    typename = std::enable_if_t<
11      std::is_arithmetic_v<U>>>
12  void doArithmeticOperation(U value) {
13    std::cout << "Doing arithmetic operation"
14      " with " << value << "\n";
15  }
16
17  // Enable this function only if T
18  // is a class type
19  template <typename U = T,
20    typename = std::enable_if_t<
21      std::is_class_v<U>>>
22  void doClassOperation(const U& obj) {
23    std::cout << "Doing class operation\n";
24  }
25};
26
27class SomeClass {};
28
29int main() {
30  MyClass<int> intClass;
31  intClass.doArithmeticOperation(42);
32
33  // This would be a compiler error
34  // intClass.doClassOperation(SomeClass{});
35
36  MyClass<SomeClass> classClass;
37  classClass.doClassOperation(SomeClass{});
38
39  // This would be a compiler error
40  // classClass.doArithmeticOperation(42);
41}

1Doing arithmetic operation with 42
2Doing class operation

In this example, the MyClass class template has two member functions: doArithmeticOperation and doClassOperation. These functions are conditionally enabled based on the properties of the template type T.

The doArithmeticOperation function is enabled only if T is an arithmetic type, using std::enable_if_t and std::is_arithmetic_v. Similarly, the doClassOperation function is enabled only if T is a class type, using std::enable_if_t and std::is_class_v.

When instantiating MyClass with int, only the doArithmeticOperation function is available. When instantiating MyClass with SomeClass, only the doClassOperation function is available. Attempting to call a disabled member function will result in a compiler error.

This technique allows you to create class templates that adapt their interface and behavior based on the properties of the template type, providing a more flexible and type-safe design.