Type Traits

Type traits are a feature of C++ that allows us to perform compile-time analysis of the types we use in our code. In this lesson, we’ll introduce type traits, and then cover examples of common use cases, including:

• Template type safety and documentation: ensuring that template functions are only called with the expected types, thereby preventing runtime errors, and improving the developer experience
• Compile-Time if statements: enabling or disabling lines of code based on the properties of a type, or other compile-time factors
• Template metaprogramming: writing code to change how templates are generated and used at compile time
• Conditional type selection: changing the data types we use based on boolean expressions
• Custom types - how our own user-defined types can interact with any of these systems

Using Type Traits

The C++ standard library includes a large collection of type traits, and related functions, within the <type_traits> header file

1#include <type_traits>
2

Type traits are within the std namespace. Almost all standard library-type traits are templated structs. They accept the type we want to investigate as a template parameter and make the result of that investigation available through a static value field.

For example, the std::is_arithmetic type trait tells us if a type is numeric:

1std::is_arithmetic<int>::value // true
2std::is_arithmetic<std::string>::value // false
3

These booleans can be used like any other boolean in our code:

1#include <type_traits>
2#include <iostream>
3#include <vector>
4
5int main() {
6  if (std::is_arithmetic<float>::value) {
7    std::cout << "float is arithmetic";
8  }
9
10  if (!std::is_arithmetic<std::string>::value) {
11    std::cout << " but std::string isn't";
12  }
13
14  using vector_trait =
15      std::is_arithmetic<std::vector<int>>;
16
17  if (!vector_trait::value) {
18    std::cout
19        << "\nNeither is std::vector<int>";
20  }
21}
22

1float is arithmetic but std::string isn't
2Neither is std::vector<int>
3

From C++17 onwards, we have a more concise way to access the value field of standard library traits. We can instead append _v to the class name or, less commonly, we can use the () operator:

1#include <type_traits>
2#include <iostream>
3
4int main() {
5  if (std::is_arithmetic_v<double>) {
6    std::cout << "double is arithmetic\n";
7  }
8  if (std::is_arithmetic<std::int32_t>()) {
9    std::cout << "int32_t is also arithmetic";
10  }
11}
12

1double is arithmetic
2int32_t is also arithmetic
3

More usefully, we’d use type traits in a situation where we don’t necessarily know what type we’re dealing with. This means type traits are most commonly used when working with templates:

1#include <type_traits>
2#include <iostream>
3
4template <typename T>
5void Function(T Param) {
6  if (std::is_arithmetic<T>::value) {
7    std::cout << "Type is arithmetic\n";
8  } else {
9    std::cout << "Type is not arithmetic\n";
10  }
11}
12
13int main() {
14  Function(100);
15  Function("Hello World");
16}
17

1Type is arithmetic
2Type is not arithmetic
3

Compile Time Conditionals with if constexpr

It’s worth reiterating that type trait code is evaluated at compile time, not run time. When we want to perform a conditional check on something that is known at compile time, we can attach constexpr to the basic if statement, creating an if constexpr statement:

1#include <type_traits>
2#include <iostream>
3
4template <typename T>
5void Function(T Param) {
6  if constexpr (is_integral_v<T>) {
7    std::cout << "Integer!\n";
8  }
9
10  if constexpr (is_floating_point_v<T>) {
11    std::cout << "Floating point number!\n";
12  }
13}
14
15int main() {
16  Function(42);
17  Function(3.14);
18}
19

1Integer!
2Floating point number!
3

By evaluating if statements at compile time, it allows non-matching code to be entirely removed. When the compiler encounters our calls to template functions, it is able to remove the conditional code from the generated function. We can imagine this process yielding results similar to the following:

1void Function(int Param) {
2  std::cout << "Integer!\n";
3}
4
5void Function(double Param) {
6  std::cout << "Floating point number!\n";
7}
8

This simpler form of output that if constexpr enables is quite important when doing more advanced work with templates. But perhaps more importantly, if our if statement can be resolved at compile time, making it if constexpr makes that behavior obvious to anyone reading our code.

As such, in situations where we can use if constexpr we generally should prefer it over if.

Below, we show more examples of if constexpr, and some more useful standard library type traits:

1#include <type_traits>
2#include <iostream>
3
4class Actor {};
5class Monster : Actor {};
6
7template <typename T>
8void Function(T Param) {
9  using namespace std;
10  if constexpr (is_pointer_v<T>) {
11    cout << "\nType is a pointer";
12  }
13
14  if constexpr (is_class_v<T>) {
15    cout << "\nType is a class";
16  }
17
18  if constexpr (is_same_v<Actor, T>) {
19    cout << ": Actor";
20  } else if constexpr (is_base_of_v<Actor, T>) {
21    cout << ": Actor (or derived from Actor)";
22  }
23}
24
25int main() {
26  int x{5};
27  Function(&x);
28
29  Actor MyActor;
30  Function(MyActor);
31
32  Monster MyMonster;
33  Function(MyMonster);
34}
35

1Type is a pointer
2Type is a class: Actor
3Type is a class: Actor (or derived from Actor)
4

For a list of all traits that are available by default, there are many standard library references we can use like cppreference.com

Type Safety with Type Traits

In the previous section, we created this simple template function.

1template <typename TFirst, typename TSecond>
2auto Average(TFirst x, TSecond y) {
3  return (x + y) / 2;
4}
5

This function allows us to pass two numeric values, and get their average. Because the types are templated, we can pass any type to this function.

However, that’s a bit too permissive. Our function is intended to work with numbers, but that is not really made explicit. What if another type is passed to this function? One of two things can happen.

In the best-case scenario, the type will not support one of the operators we’re using in the function, such as /. This will result in a compiler error, albeit not a very clear one:

1binary '/':
2'std::basic_string<char,std::char_traits<char>,std::allocator<char>>'
3does not define this operator or a conversion to a type acceptable
4to the predefined operator
5

In the worst case, the type we pass does implement all the required operators, but the use case for those operators is not the same as what our function is assuming. For example, our template function is assuming the + and / operators of the provided type are used for arithmetic addition and division.

But types are free to overload the + and / operators for any purpose - they don’t need to mean addition and division.

In such a case, the compiler will be happy to instantiate the template, because the type meets all the requirements. We won’t get any compiler error - we’ll instead have introduced a bug.

Type traits allow us to be more explicit about the requirements of our types. The most basic example of this is simply using a static_assert to ensure the type meets the expected criteria:

1#include <type_traits>
2
3template <typename TFirst, typename TSecond>
4auto Average(TFirst x, TSecond y) {
5  static_assert(
6      std::is_arithmetic<TFirst>::value,
7      "Average: First argument must be arithmetic");
8  static_assert(
9      std::is_arithmetic<TSecond>::value,
10      "Average: Second argument must be arithmetic");
11  return (x + y) / 2;
12}
13

This has three benefits:

• It implements the desired requirements. Now, the compiler will ensure that the provided type is a number - not just that it implements the + and / operators.
• It documents our requirements. Anyone looking at our Average function will be able to see what the requirements are. Some IDEs will also be able to better understand the requirements of this function, and provide immediate feedback as we’re writing the code
• If a type doesn’t meet the requirements, the error message will be more useful:

1int main() {
2  Average("Hello", "World");
3}
4

1static_assert failed: 'Average: First argument must be arithmetic'
2static_assert failed: 'Average: Second argument must be arithmetic'
3

std::enable_if and SFINAE

The std::enable_if trait accepts two template parameters - a boolean and a type. If the boolean is true, the resulting struct has a type field, containing the type we passed.

In other words, we can imagine the following code:

1#include <type_traits>
2
3int main() {
4  std::enable_if<true, int>::type MyInt{42};
5}
6

At compile time, we can imagine our enable_if code will resolve simply to int, meaning our code is equivalent to this:

1#include <type_traits>
2
3int main() {
4  int MyInt{42};
5}
6

More commonly, we use the std::enable_if_t alias, which gives us direct access to the type:

1std::enable_if_t<true, int> MyInt{42};
2

Let's see what happens when the boolean value is false:

1#include <type_traits>
2
3int main() {
4  std::enable_if<false, int>::type MyInt{42};
5}
6

In this case, we can imagine our code being equivalent to this:

1#include <type_traits>
2
3int main() {
4  MyInt{42};
5}
6

This code is invalid, so we get a compilation error. So, how is any of this useful?

It relates to a rule around function templates, called substitution failure is not an error, or SFINAE

In general, it means that when the compiler is considering whether a function template can create a function to serve a function call. When we substitute the types passed to our function call into a function template, it is okay if that process results in invalid code.

That template just gets ignored and the compiler moves on to the other candidates.

We can create template functions that may conditionally result in substitution failure. For example, consider the following function:

1using std::enable_if_t, std::is_class_v;
2template <typename T,
3          enable_if_t<is_class_v<T>, int> = 0>
4void Function(T Arg) {}
5

If T is a class, our template substitution will look something like this:

1template <typename T, int = 0>
2void Function(T Arg) {}
3

The above is entirely valid, so this function will be able to handle our call. However, if T is not a class, our template will look like this after substitution:

1template <typename T, = 0>
2void Function(T Arg) {}
3

This time, the resulting code was not valid. But, under the SFINAE rule, substitution failure does not mean our program necessarily fails to compile. It means this template cannot be used to create a function with the argument types provided, but there may be another template that can serve the request.

Below, we have a template that will result in substitution failure if the provided type is a class, and another that will result in substitution failure if the type is not a class.

1#include <type_traits>
2#include <iostream>;
3
4using std::enable_if_t, std::is_class_v;
5template <typename T,
6          enable_if_t<is_class_v<T>, int> = 0>
7void Function(T Arg) {
8  std::cout << "That was a class\n";
9}
10
11template <typename T,
12          enable_if_t<!is_class_v<T>, int> = 0>
13void Function(T Arg) {
14  std::cout << "That wasn't\n";
15}
16
17class Character {};
18
19int main() {
20  Function(Character{});
21  Function(3.14);
22}
23

The program compiles and runs successfully, because substitution failure is not an error, and all function calls were able to be handled by a template that didn’t suffer substitution failure:

1That was a class
2That wasn't
3

If the above code feels overly complicated, don’t worry - it is.

This is a brief introduction to a topic known as template metaprogramming, which is notoriously difficult and unfriendly. So much so that C++20 introduced a new language feature called concepts that makes many of the use cases for template metaprogramming more accessible.

We introduce concepts in the next lesson.

Conditional Type Selection with std::conditional

Within type_traits, the std::conditional template lets us dynamically select a type to use at compile time. It accepts three template parameters - a boolean value, a type to use if the boolean is true, and a type to use if the boolean is false. The resulting type is available from the type static member.

Here are some examples:

1using namespace std;
2
3// This will be int
4conditional<true, int, float>::type
5
6// We can use conditional_t to access ::type directly
7// This will be std::string
8conditional_t<true, string, char*>
9
10// The bool can be any expression known at compile time
11// This will be std::string
12constexpr bool useStdString{true};
13conditional_t<useStdString, string, char*>
14
15// This will be std::vector<float>
16conditional_t<false, vector<int>, vector<float>>
17
18// This will be std::vector<float> too
19vector<conditional_t<false, int, float>>
20

Typically, std::conditional is used to create a type alias, which we can then easily use throughout our code:

1#include <iostream>
2#include <type_traits> // for std::conditional
3#include <typeinfo> // for typeid
4
5constexpr bool Use64BitIntegers{true};
6using integer =
7    std::conditional<Use64BitIntegers,
8                     std::int64_t,
9                     std::int32_t>::type;
10
11int main() {
12  integer MyInt{42};
13  std::cout << typeid(integer).name() << " ("
14            << sizeof(integer) << " bytes)";
15}
16

1__int64 (8 bytes)
2

Altering Types

The type_traits header has a range of utilities that receive a type, and return a new type based on that input. For example, the std::remove_const struct is created by providing a type as a template parameter.

A resulting type is available within the type static member, which is equivalent to the input type, with the const specifier removed.

1// Results in int
2std::remove_const<const int>::type
3
4// We can append _t instead of accessing ::type
5// This results in int
6std::remove_const_t<const int>
7
8// The input type does not need to be const
9// This results in int
10std::remove_const_t<int>
11  
12

This is typically used when we want to compare types, but we don’t necessarily care if the types have specifiers such as const:

1#include <iostream>
2#include <type_traits>
3
4// Compares types without removing const
5template <typename TFirst, typename TSecond>
6void FuncA(TFirst& A, TSecond& B) {
7  using namespace std;
8  if constexpr (is_same_v<TFirst, TSecond>) {
9    cout << "FuncA: Types are the same\n";
10  } else {
11    cout << "FuncA: Types are not the same\n";
12  }
13}
14
15// Removes const, then compares types
16template <typename TFirst, typename TSecond>
17void FuncB(TFirst& A, TSecond& B) {
18  using namespace std;
19  if constexpr (is_same_v<
20                    remove_const_t<TFirst>,
21                    remove_const_t<TSecond>>) {
22    cout << "\nFuncB: Types are the same";
23  } else {
24    cout << "\nFuncB: Types are not the same";
25  }
26}
27
28int main() {
29  int x{1};
30  const int y{2};
31
32  FuncA(x, x);
33  FuncA(x, y);
34
35  FuncB(x, x);
36  FuncB(x, y);
37}
38

1FuncA: Types are the same
2FuncA: Types are not the same
3
4FuncB: Types are the same
5FuncB: Types are the same
6

The standard library includes several more helpers to modify types in similar ways. A standard library reference such as cppreference.com will include a complete list.

Creating our own Type Traits

As usual, we’re not restricted to just the type traits that come with the standard library. We can get pull traits in from third-party libraries or create our own. Let's imagine we have a template function that receives objects that may or may not have a render function. We’d like to write an is_renderable trait to help us out:

1template <typename T>
2void Function(T Param) {
3  if constexpr (is_renderable<T>::value) {
4    Param.Render();
5  } else {
6    std::cout << "\nNot Renderable";
7  }
8}
9

Standard library-type traits typically make a boolean available as the value field. We can easily make our struct behave in the same way by inheriting from the helper classes std::false_type and std::true_type, available by including <type_traits>.

Typically, we’ll want value to be false by default, so we inherit from false_type:

1template <typename>
2struct is_renderable : std::false_type {};
3

Then, for any class where we want the trait to be true, we can provide a specialization of our type trait that inherits from true_type instead:

1template <>
2struct is_renderable<MyClass> : std::true_type {};
3

With these 4 lines of code, we now have our own custom-type trait working:

1#include <type_traits>
2#include <iostream>
3
4template <typename>
5struct is_renderable : std::false_type {};
6
7class Fish {
8 public:
9  void Render() {
10    std::cout << "Fish: ><((((`>";
11  }
12};
13
14template <>
15struct is_renderable<Fish> : std::true_type {};
16
17class Sound {};
18
19template <typename T>
20void Function(T Param) {
21  if constexpr (is_renderable<T>::value) {
22    Param.Render();
23  } else {
24    std::cout << "\nNot Renderable";
25  }
26}
27
28int main() {
29  Fish MyFish;
30  Function(MyFish);
31
32  Sound MySound;
33  Function(MySound);
34}
35

1Fish: ><((((`>
2Not Renderable
3

There is much more we can do with type traits and templates in general, but we don’t want to get too advanced in this course. Additionally, a new addition to the C++20 overlaps with type traits somewhat, and it’s useful to understand our options before going too deep.

This new addition is called concepts, and we cover it in the next lesson.