Run Time Type Information (RTTI) and typeid()

In our introductory course, we introduced the concepts of inheritance and polymorphism. One of the implications of these techniques is that, when one of our functions receive a reference to an object, they don’t necessarily know the exact type of the object.

In the following example, our Handle() function knows on each invocation it is going to be receiving a reference to a Monster, but it doesn’t know the exact type of that Monster. It could be a basic Monster, or it could be any subtype of Monster, such as a Dragon:

1class Monster {
2 public:
3  virtual ~Monster(){}
4};
5
6class Dragon : public Monster {};
7
8void Handle(Monster& Enemy) {}

To help us out with scenarios like this, compilers add some additional information to our compiled programs, enabling us to write code that can figure out what type any object is at run time.

This mechanism is called Run-Time Type Information (RTTI), and it unlocks two features that can help us - the typeid() operator, and dynamic casting.

The typeid() operator

The main way we can get information about a type at run time is through the typeid() operator, available after including <typeinfo>:

1#include <typeinfo>
2
3int main() {
4  int Number{42};
5  typeid(Number);
6}

This returns a std::type_info object, which we can capture by constant reference:

1#include <typeinfo>
2
3int main() {
4  int Number{42};
5  const std::type_info& TypeInfo{typeid(Number)};
6}

The std::type_info type has a name() method, which returns a string representation of what the type is. This method is rarely used within the logic of our program, but it can be helpful for logging and debugging:

1#include <typeinfo>
2#include <iostream>
3
4int main() {
5  int Number{42};
6  const std::type_info& TypeInfo{typeid(Number)};
7
8  std::cout << "Number has type: "
9    << TypeInfo.name();
10}

1Number has type: int

We can also directly provide a type to the typeid() operator, rather than an expression. This somewhat useless example demonstrates this in action:

1#include <iostream>
2#include <typeinfo>
3
4int main() {
5  std::cout << "int has type: "
6    << typeid(int).name();
7}

1int has type: int

Later in this lesson, we’ll see the main use cases where passing a type to typeid is practically useful. However, one situation where we may find it helpful is when the type name is a template parameter:

1#include <iostream>
2#include <typeinfo>
3
4template <typename T>
5struct Container {
6  void Log() {
7    std::cout << "\nI am storing type: "
8      << typeid(T).name();
9  }
10
11  T Value;
12};
13
14int main() {
15  Container<int> IntContainer;
16  IntContainer.Log();
17
18  Container<float> FloatContainer;
19  FloatContainer.Log();
20}

1I am storing type: int
2I am storing type: float

Comparing Types at Runtime

The most practically useful feature of the std::type_info type is that it has implemented the == and != operators. This allows us to compare types within our program, and implement different runtime behavior as needed:

1#include <iostream>
2#include <typeinfo>
3
4int main() {
5  int Number{42};
6
7  if (typeid(Number) == typeid(int)) {
8    std::cout << "Number is an int";
9  }
10
11  if (typeid(Number) != typeid(float)) {
12    std::cout << "\nIt is not a float";
13  }
14}

1Number is an int
2It is not a float

The main use case for this is when we receive a pointer or reference to an object of a polymorphic type, and we need to find out whether it has a more derived subtype than what is represented by the pointer or reference type. We cover this in the next section.

Comparing Polymorphic Types

The main use case for typeid() comparisons is when working with polymorphic types, as an alternative to dynamic_cast(). We covered polymorphic types and dynamic casting in detail in our lesson on downcasting, and familiarity with those concepts will be very helpful for understanding the rest of this section:

Downcasting

Get to grips with downcasting in C++, including static and dynamic casts. This lesson provides clear explanations and practical examples for beginners

In that lesson, we introduced a scenario where we had a function that accepted a Monster by reference:

Monster Class (Unchanged)|Show
1class Monster {/*...*/};
6
7class Dragon : public Monster {};
8
9void Log(Monster& Enemy) {}
10
11int main() {
12  Dragon SomeDragon;
13  Log(SomeDragon);
14
15  Monster SomeGoblin;
16  Log(SomeGoblin);
17}

Monster is a polymorphic type so, for any given invocation, the Log() function doesn’t know the exact type of Enemy it is working with. It could be a basic Monster, or it could be any subclass of Monster, such as a Dragon.

We saw how dynamic_cast() could help our function figure out what it’s dealing with, and react accordingly:

1#include <iostream>
2
Monster Class (Unchanged)|Show
3class Monster {/*...*/};
8
9class Dragon : public Monster {};
10
11void Log(Monster& Enemy) {
12  Dragon* DragonPtr{
13    dynamic_cast<Dragon*>(&Enemy)};
14
15  if (DragonPtr) {
16    std::cout << "That's a dragon\n";
17  } else {
18    std::cout << "That's not a dragon\n";
19  }
20}
21
main Function (Unchanged)|Show
22int main() {/*...*/}

1That's a dragon
2That's not a dragon

We can now implement this behavior more directly, using typeid() comparisons:

1#include <iostream>
2#include <typeinfo>
3
Monster Class (Unchanged)|Show
4class Monster {/*...*/};
9
10class Dragon : public Monster {};
11
12void Log(Monster& Enemy) {
13  if (typeid(Enemy) == typeid(Dragon)) {
14    std::cout << "That's a dragon\n";
15  } else {
16    std::cout << "That's not a dragon\n";
17  }
18}
19
main Function (Unchanged)|Show
20int main() {/*...*/}

1That's a dragon
2That's not a dragon

The main advantage dynamic_cast() has over typeid() comparison is that it returns a pointer, which is useful if we need to perform any follow-up operations if the object did indeed have the type we were testing for.

For example, if we wanted to access any Dragon class members, we’d still want to use dynamic_cast() here.

But if we don’t need that, and we just need to find out what type we’re dealing with, the typeid() approach is simpler, easier to understand, and slightly better for performance.

Comparing Template Types

Template parameters can also be polymorphic types, so it is sometimes useful to perform runtime comparisons on them using the typeid() operator. Below, we’ve replicated the previous example, except we’ve replaced our Monster type with a templated typename T.

Our template is instantiated once, to create a function that receives a Monster&, and then uses typeid() to determine which specific type of Monster it received at run time:

1#include <iostream>
2#include <typeinfo>
3
Monster Class (Unchanged)|Show
4class Monster {/*...*/};
9
10class Dragon : public Monster {};
11
12template <typename T>
13void Log(T& Enemy) {
14  if (typeid(Enemy) == typeid(Dragon)) {
15    std::cout << "That's a dragon\n";
16  } else {
17    std::cout << "That's not a dragon\n";
18  }
19}
20
21int main() {
22  Dragon SomeDragon;
23  Log<Monster>(SomeDragon);
24
25  Monster SomeGoblin;
26  Log<Monster>(SomeGoblin);
27}

1That's a dragon
2That's not a dragon

1#include <iostream>
2#include <concepts>
3
Monster Class (Unchanged)|Show
4class Monster {/*...*/};
9
10class Dragon : public Monster {};
11
12template <typename T>
13void Log(T Enemy) {
14  if constexpr (std::same_as<T, Dragon>) {
15    std::cout << "That's a dragon\n";
16  } else {
17    std::cout << "That's not a dragon\n";
18  }
19}
20
21int main() {
22  Dragon SomeDragon;
23  Log<Dragon>(SomeDragon);
24
25  Monster SomeGoblin;
26  Log<Monster>(SomeGoblin);
27}

1That's a dragon
2That's not a dragon

1void Log(Dragon Enemy) {
2  std::cout << "That's a dragon\n";
3}

1void Log(SomeOtherType Enemy) {
2  std::cout << "That's not a dragon\n";
3}

std::type_info and std::type_index

The std::type_info objects returned by the typeid() operator are closely linked to our compiler’s internal workings, and its implementation of RTTI. As such, we’re quite limited in what we can do with them. For example, we can’t create copies of these objects:

1#include <typeinfo>
2
3int main() {
4  int Number{42};
5  std::type_info TypeInfo{typeid(Number)};
6}

1error C2280: 'type_info::type_info(const type_info &)': attempting to reference a deleted function

std::type_info objects not being copy-constructible is the reason we’ve been capturing them by const reference in previous examples.

To give us more flexibility when working with these objects, the C++ specification introduced the std::type_index type, which is designed to be a friendlier wrapper around a std::type_info object.

A std::type_index is constructible from a std::type_info, meaning it is constructible from what is returned by the typeid() operator:

1#include <typeinfo>
2#include <typeindex> 
3
4int main() {
5  int Number{42};
6  std::type_index TypeInfo{typeid(Number)}; 
7}

For more elaborate projects that require type info to be stored in variables and passed around to other functions, we’ll often prefer to use std::type_index over the more primitive std::type_info.

Run Time Type Deduction without RTTI

To support RTTI, compilers need to insert additional data into our compiled binary, describing our types. This makes our compiled package larger so, as an optional optimization, compilers provide the option to disable RTTI entirely.

This can be useful in environments where resources are highly constrained, or for projects that don’t require RTTI-based features (typeid and dynamic_cast)

When working in environments without RTTI, we can always recreate those capabilities in other ways. For example, we can simply add type information as members of classes that need it.

Below, our base Monster polymorphic type implements a GetType() method, which derived classes can override. This allows us to recreate the previous example, without needing typeid():

1#include <iostream>
2
3enum class MonsterType {Monster, Dragon};
4
5class Monster {
6 public:
7   virtual MonsterType GetType() const {
8     return MonsterType::Monster;
9  }
10};
11
12class Dragon : public Monster {
13 public:
14   MonsterType GetType() const override {
15     return MonsterType::Dragon;
16  }
17};
18
19void Log(Monster& Enemy) {
20   if (Enemy.GetType() == MonsterType::Dragon) {
21     std::cout << "That's a dragon";
22   }
23}
24
25int main() {
26  Dragon SomeEnemy;
27  Log(SomeEnemy);
28}

1That's a dragon

Rather than using dynamic_cast() to access derived class members, we can first examine the type to ensure the cast will succeed, and then use static_cast().

Below, we use static_cast() to generate a Dragon pointer, within an if statement that has already confirmed our Enemy is indeed a Dragon:

1#include <iostream>
2
3enum class MonsterType {Monster, Dragon};
4
Monster Class (Unchanged)|Show
5class Monster {/*...*/};
12
13class Dragon : public Monster {
14 public:
15   MonsterType GetType() const override {
16     return MonsterType::Dragon;
17  }
18
19   void DragonFunction() {
20     std::cout << "Dragon Things";
21   }
22};
23
24void Log(Monster& Enemy) {
25   if (Enemy.GetType() == MonsterType::Dragon) {
26     Dragon* DragonPtr{
27       static_cast<Dragon*>(&Enemy)};
28     DragonPtr->DragonFunction();
29   }
30}
31
32int main() {
33  Dragon SomeEnemy;
34  Log(SomeEnemy);
35}

1Dragon Things

Summary

This lesson explored Run-Time Type Information (RTTI) and features it supports. The key takeaways include:

• Introduction to RTTI and its importane for identifying object types at runtime.
• Usage of the typeid() operator to obtain type information of expressions and types.
• How to compare types at runtime using the == and != operators with std::type_info.
• Application of typeid() in working with polymorphic types and its comparison with dynamic_cast().
• Use of typeid() with template types for runtime type identification.
• Understanding the limitations of std::type_info and the introduction of std::type_index for more flexible type handling.
• Strategies for type deduction without relying on RTTI, illustrating alternative approaches in resource-constrained environments.

Next Lesson

Errors and Assertions

Learn how we can ensure that our application is in a valid state using compile-time and run-time assertions.

ContinueView Course