Using Type Traits with Function Templates

You can use type traits in combination with tag dispatch or if constexpr to provide different implementations of a function template based on the properties of the template type. Here's an example using both techniques:

1#include <iostream>
2#include <type_traits>
3#include <string>
4
5// Tag dispatch implementation
6template <typename T>
7void printValueImpl(T value, std::true_type) {
8  std::cout << "Arithmetic value: "
9    << value << "\n";
10}
11
12template <typename T>
13void printValueImpl(T value, std::false_type) {
14  std::cout << "Non-arithmetic value: "
15    << value << "\n";
16}
17
18template <typename T>
19void printValue(T value) {
20  printValueImpl(value, std::is_arithmetic<T>{});
21}
22
23// if constexpr implementation
24template <typename T>
25void printValueIfConstexpr(T value) {
26  if constexpr (std::is_arithmetic_v<T>) {
27    std::cout << "Arithmetic value: "
28      << value << "\n";
29  } else {
30    std::cout << "Non-arithmetic value: "
31      << value << "\n";
32  }
33}
34
35int main() {
36  int num = 42;
37  std::string str = "Hello";
38
39  printValue(num);
40  printValue(str);
41
42  printValueIfConstexpr(num);
43  printValueIfConstexpr(str);
44}

1Arithmetic value: 42
2Non-arithmetic value: Hello
3Arithmetic value: 42
4Non-arithmetic value: Hello

In this example, we have two different techniques to provide different implementations of a function template based on whether the template type is an arithmetic type or not.

1. Tag Dispatch:
   • The printValueImpl function is overloaded based on the second argument, which is a type trait (std::true_type or std::false_type).
   • The printValue function delegates the call to printValueImpl by passing the appropriate type trait based on std::is_arithmetic.
   • The compiler selects the appropriate overload of printValueImpl based on the type trait.
2. if constexpr:
   • The printValueIfConstexpr function uses if constexpr to conditionally compile different code paths based on the result of std::is_arithmetic_v.
   • If T is an arithmetic type, the first code block is compiled; otherwise, the second code block is compiled.

Both techniques achieve the same result, providing different implementations based on the properties of the template type.

Using type traits in this manner allows you to create more flexible and adaptable function templates that can handle different types differently based on their properties.