Type Traits: Compile-Time Type Analysis

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

1struct SomeStruct {
2  using type = bool;
3  static const int value{42};
4};
5
6int main() {
7  // This will be a bool
8  SomeStruct::type MyVariableA;
9
10  // This will have a value of 42
11  int MyVariableB = SomeStruct::value;
12}

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>

Type traits are within the std namespace, and almost all of them are struct templates. 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:

1#include <type_traits>
2#include <iostream>
3
4int main() {
5  if (std::is_arithmetic<int>::value) {
6    std::cout << "int is arithmetic";
7  }
8  if (!std::is_arithmetic<std::string>::value) {
9    std::cout << "\nbut std::string isn't";
10  }
11}

1int is arithmetic
2but std::string isn't

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}

1double is arithmetic
2int32_t is also arithmetic

Type Traits with Templates

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_v<T>) {
7    std::cout << Param << " is arithmetic\n";
8  } else {
9    std::cout << Param << " is not arithmetic\n";
10  }
11}
12
13int main() {
14  Function(42);
15  Function("Hello World");
16}

142 is arithmetic
2Hello World is not arithmetic

Using if constexpr Statements

The logic we implement with type traits is evaluated at compile time. For example, a statement like std::is_arithmetic_v<T> will be determined at compile time, and the result of that expression will then be available at run time.

For example, imagine we have the following code:

1#include <type_traits>
2#include <iostream>
3
4template <typename T>
5void LogDouble(T Param) {
6  if (std::is_arithmetic_v<T>) {
7    std::cout << "Double: " << Param * 2;
8  }
9}
10
11int main() {
12  LogDouble(42);
13  LogDouble(std::string("Hello World"));
14}

After our templates are instantiated and our type trait evaluated, we can imagine we have two functions, one instantiated when T is an int, and one instantiated when T is a std::string:

1void LogDouble(int Param) {
2  if (true) {
3    std::cout << "Double: " << Param * 2;
4  }
5}
6void LogDouble(std::string Param) {
7  if (false) {
8    std::cout << "Double: " << Param * 2;
9  }
10}

This is a problem because std::string does not implement the * operator, so we get a compilation error even though that statement was within an if (false) block:

1error: binary '*': 'T' does not define this operator or a conversion to a type acceptable to the predefined operator

To address this, C++17 introduced if constexpr statements. These are evaluated at compile time and, if the expression we pass to if constexpr evaluates to false, the block of code is removed from our function entirely.

Let’s apply it to our previous example:

1#include <iostream>
2#include <type_traits>
3
4template <typename T>
5void LogDouble(T Param) {
6  if constexpr (std::is_arithmetic_v<T>) {  
7    std::cout << "Double: " << Param * 2;
8  }
9}
10
11int main() {
12  LogDouble(42);
13  LogDouble(std::string("Hello World"));
14}

Now, we can imagine our instantiated functions look like this:

1void LogDouble(int Param) {
2  std::cout << "Double: " << Param * 2;
3}
4
5void LogDouble(std::string Param) {}

There’s no longer any compiler error here, so our program runs successfully and outputs:

1Double: 84

More Standard Library Examples

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

• std::is_pointer lets us determine if a type is a pointer
• std::is_class lets us determine if a type is a class or struct, excluding enums and unions (which we cover later in the course)
• std::is_same lets us determine if a type is the same as another type
• std::is_base_of lets us determine if a type is the same as another type, or derived from that type through inheritance

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

1&x:
2Type is a pointer
3
4MyActor:
5Type is a class
6Type is an Actor
7Type is derived from Actor
8
9MyMonster:
10Type is a class
11Type is derived from Actor

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

Using static_assert()

One of the main uses for type traits is to ensure a provided type meets the expectations of our template. For example, let’s imagine we created this simple template function.

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

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 made explicit. What if a different, unexpected 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, although for someone not familiar with our template, it doesn’t describe the core problem:

1template <typename T1, typename T2>
2auto Average(T1 x, T2 y) {
3  return (x + y) / 2;
4}
5
6int main() {
7  Average("Hello", "World");
8}

1error C2110: '+': cannot add two pointers

In the worst case, the type we pass does implement all the required operators, but not in the way that our template is assuming. Types are free to implement operators like + and / in any way they want - they don’t need to represent addition and division.

As such, our template will accept those objects without any compilation error, resulting in unexpected behaviour at run time.

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 T1, typename T2>
4auto Average(T1 x, T2 y) {
5  static_assert(std::is_arithmetic_v<T1>
6    && std::is_arithmetic_v<T2>,
7    "Average: Arguments must be numeric");
8
9  return (x + y) / 2;
10}
11
12int main() {
13  Average("Hello", "World");
14}

1error: static_assert failed: 'Average: Arguments must be numeric'

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 someone tries to use our template with a type that doesn’t meet the requirements, we get to provide a custom, contextual error message.

Comparing Types

One of the main use cases we have for type traits is to determine if some template typename T matches a specific type. Below, our template has a different implementation depending on whether it was instantiated with an int or not:

1#include <iostream>
2#include <type_traits>
3
4template <typename T>
5void Print(T&& x) {
6  if constexpr (std::is_same_v<T, int>) {
7    std::cout << x << " is an int\n";
8  } else {
9    std::cout << x << " is not an int\n";
10  }
11}
12
13int main() {
14  Print(1);
15}

11 is an int

Preview: Forwarding References

The previous example uses a forwarding reference, denoted by the double ampersand && prepended to a template type. We’re using a forwarding reference here because it can capture both lvalue and rvalue references.

Further nuance isn’t important for this introduction to type traits, but we cover forwarding references in detail later in the course:

Perfect Forwarding and std::forward

An introduction to problems that can arise when our functions forward their parameters to other functions, and how we can solve those problems with std::forward

The comparisons carried out by these type traits are often more strict than we need. For example, if our type is a const int, the non-int code path will be used, because a const int is not the same as an int.

Similar distinctions are made between value categories and reference types, further disrupting our intended design:

1#include <type_traits>
2#include <iostream>
3
4template <typename T>
5void Print(T&& x) {
6  if constexpr (std::is_same_v<T, int>) {
7    std::cout << x << " is an int\n";
8  } else {
9    std::cout << x << " is not an int\n";
10  }
11}
12
13int main() {
14  Print(1);
15
16  int y{2};
17  Print(y);
18
19  const int x{3};
20  Print(x);
21}

11 is an int
22 is not an int
33 is not an int

Often, the logic we’re trying to implement doesn’t care whether our types are constant, or whether they’re references. To implement these agnostic comparisons, the standard library includes further traits, such as std::remove_const and std::remove_reference.

We pass a type to these traits, and they return a type that is possibly different. The returned type will be the same as the type we provide but with any const or reference aspect removed.

The new type is available as the ::type static member, or by appending _t to the struct name:

1#include <iostream>
2#include <type_traits>
3
4int main() {
5  if constexpr (std::is_same_v<int,
6    std::remove_const<const int>::type>) {
7    std::cout << "Those are the same";
8  }
9
10  if constexpr (std::is_same_v<int,
11    std::remove_reference_t<int&>>) {
12    std::cout << "\nThose are the same too";
13  }
14}

1Those are the same
2Those are the same too

We can remove both const and references at once using std::remove_cvref:

1#include <iostream>
2#include <type_traits>
3
4int main() {
5  if constexpr (std::is_same_v<int,
6    std::remove_cvref_t<const int&>>) {
7    std::cout << "Those are the same";
8  }
9}

1Those are the same

1volatile int SomeInteger{42};

1#include <iostream>
2#include <type_traits>
3
4int main() {
5  if constexpr (std::is_same_v<int,
6    std::remove_volatile_t<volatile int>>) {
7    std::cout << "Those are the same";
8  }
9}

1Those are the same

Let’s apply this to fix the problem we had with our template. We create a type alias BaseType using the type returned from std::remove_cvref_t:

1#include <iostream>
2#include <type_traits>
3
4template <typename T>
5void Print(T&& x) {
6  using BaseType = std::remove_cvref_t<T>;       
7
8  if constexpr (std::is_same_v<BaseType, int>) {  
9    std::cout << x << " is an int\n";
10  } else {
11    std::cout << x << " is not an int\n";
12  }
13}
14
15int main() {
16  Print(1);
17
18  int y{2};
19  Print(y);
20
21  const int x{3};
22  Print(x);
23}

11 is an int
22 is an int
33 is an int

Note that std::remove_cvref and similar type traits are not modifying our function parameter. For example, if x is const, it continues to be const in our previous example.

Type traits like std::remove_cvref simply receive a type as an argument, and return a type that does not have those characteristics.

Creating our own Type Traits

As usual, we’re not restricted to just the type traits that come with the standard library. We can 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 Render(T Param) {
3  if constexpr (is_renderable<T>::value) {
4    Param.Render();
5  } else {
6    std::cout << "\nNot Renderable";
7  }
8}

Standard library-type traits that answer questions like this are struct templates that accept a type as a template argument, and make the boolean result available as a value static member. We can follow the same convention. We’d initially want our type trait’s value to be false, meaning any arbitrary object does not satisfy our type trait by default:

1template <typename T>
2struct is_renderable {
3  static const bool value{false};
4};

Now, for any type we create that does satisfy the requirement, we can specialize the type trait template to make the value true. In the following code, is_renderable<T>::value will be true if T is Fish, and false for any other type:

1#include <iostream>
2
3// General Template
4template <typename T>
5struct is_renderable {
6  static const bool value{false};
7};
8
9class Fish {
10 public:
11  void Render() {
12    std::cout << "Fish: ><((((`>";
13  }
14};
15
16// Specialized Template
17template<>
18struct is_renderable<Fish> {
19  static const bool value{true};
20};
21
Render Template (Unchanged)|Show
22void Render(T Param) {/*...*/}
31
32int main() {
33  Fish MyFish;
34  Render(MyFish); // Renderable
35  Render(42);     // Not Renderable
36}

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

Template Specialization

A practical guide to template specialization in C++ covering full and partial specialization, and the scenarios where they’re useful

std::false_type and std::true_type

The standard library’s <type_traits> header includes a pair of utilities that make type traits slightly faster to implement. Rather than defining our value static members, we can just inherit them from a base struct.

Our struct can inherit from std::false_type in the general case (when we want value to be false) and std::true_type when specializing the type trait to set value to true.

1// General Template
2template <typename>
3struct MyTrait : std::false_type {};
4
5// Specialized Template
6template <>
7struct MyTrait<SomeType> : std::true_type {};

Below, we’ve updated our previous is_renderable example to use this technique:

1#include <iostream>
2#include <type_traits>
3
4// General Template
5template <typename>
6struct is_renderable : std::false_type {};
7
Fish Class (Unchanged)|Show
8class Fish {/*...*/};
15
16// Specialized Template
17template <>
18struct is_renderable<Fish> : std::true_type {};
19
Render Template (Unchanged)|Show
20void Render(T Param) {/*...*/}
29
main Function (Unchanged)|Show
30int main() {/*...*/}

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

Implementing the _v and _t Pattern

As we’ve seen, the standard library’s type traits make their results available through variables suffixed with _v (for values) and _t (for types). For example, std::is_integral_v<T> is equivalent to std::is_integral<T>::value.

We can implement the same API for our own type traits, using a variable template that retrieves the correct static member from our struct:

1#include <iostream>
2#include <type_traits>
3
General Template (Unchanged)|Show
4struct is_renderable {/*...*/};
7
8template <typename T>
9constexpr bool is_renderable_v{
10  is_renderable<T>::value};
11
Fish Class (Unchanged)|Show
12class Fish {/*...*/};
19
Specialized Template (Unchanged)|Show
20struct is_renderable<Fish> {/*...*/};
23
24template <typename T>
25void Render(T Param) {
26  if constexpr (is_renderable_v<T>) {
27    Param.Render();
28  } else {
29    std::cout << "\nNot Renderable";
30  }
31}
32
main Function (Unchanged)|Show
33int main() {/*...*/}

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

Summary

In this lesson, we introduced type traits in C++ and explored their common use cases. We learned how to use type traits from the <type_traits> header to perform compile-time analysis of types. Key takeaways:

• Type traits allow compile-time analysis of types
• if constexpr enables conditional compilation based on type traits
• static_assert can enforce type requirements in templates
• Custom type traits can be created using struct templates and specialization
• Type traits improve template safety, documentation, and error messages

Next Lesson

Using SFINAE to Control Overload Resolution

Learn how SFINAE allows templates to remove themselves from overload resolution based on their arguments, and apply it in practical examples.

ContinueView Course