Run-Time Type Identification (RTTI) in C++ with Detailed Examples

In this post, we will discuss Run-Time Type Identification (RTTI) in C++, a feature that allows us to obtain type information for objects at runtime. We will explore how RTTI works, its applications, and provide detailed examples to demonstrate its usage using snake_case naming convention.

What is Run-Time Type Identification (RTTI)?

Run-Time Type Identification (RTTI) is a C++ language feature that provides a mechanism for determining the type of an object during program execution. It allows us to inspect and manipulate type information at runtime, which can be useful for debugging purposes, implementing polymorphic behaviors, or working with template functions and classes.

RTTI is available in most modern C++ compilers and is enabled by default. However, it can be disabled using compiler-specific options, such as -fno-rtti for GCC and Clang, or /GR- for MSVC.

RTTI Mechanisms

C++ provides two primary mechanisms for performing RTTI:

• typeid operator
• dynamic_cast operator

typeid Operator

The typeid operator is used to obtain a reference to a std::type_info object representing the type of an expression. The std::type_info class is defined in the <typeinfo> header and provides several member functions for comparing and inspecting type information.

Here’s a simple example of using the typeid operator:

#include <iostream>
#include <typeinfo>

class base {
public:
    virtual ~base() {}
};

class derived : public base {
};

int main() {
    base* base_ptr = new derived();
    std::cout << "Type of base_ptr: "
              << typeid(*base_ptr).name() << std::endl;
    delete base_ptr;
    return 0;
}

Example output of the program using g++:

$ g++ -std=c++20 1.cpp -o 1

$ ./1 
Type of base_ptr: 7derived

In this example, we use the typeid operator to obtain the std::type_info object for a base pointer pointing to a derived object. Since the base class has at least one virtual function, the typeid operator will correctly identify the dynamic type of the object, which is derived.

dynamic_cast Operator

The dynamic_cast operator is used to safely convert pointers or references between related classes in a class hierarchy. It checks at runtime whether the conversion is valid and returns a null pointer (for pointers) or throws a std::bad_cast exception (for references) if the conversion is not possible.

Here’s an example of using dynamic_cast:

#include <iostream>

class base {
public:
    virtual ~base() {}
};

class derived : public base {
};

int main() {
    base* base_ptr = new derived();
    derived* derived_ptr = dynamic_cast<derived*>(base_ptr);

    if (derived_ptr) {
        std::cout << "Successfully casted to derived." << std::endl;
    } else {
        std::cout << "Failed to cast to derived." << std::endl;
    }

    delete base_ptr;
    return 0;
}

In this example, we use dynamic_cast to attempt to cast a base pointer pointing to a derived object to a derived pointer. Since the base class has at least one virtual function, and the pointer indeed points to a derived object, the dynamic_cast succeeds, and derived_ptr is set to a valid pointer.

RTTI Use Cases

RTTI has a variety of applications and use cases:

• Polymorphism: RTII gives the program the ability to decide the type desired or in use during run time, and hence it can be used to support polymorphism. In the later example, we will illustrate the usage with a polymorphic factory.
• Debugging and diagnostics: RTTI can be useful for tracing the types of objects in a program at runtime. By examining the type information, developers can gain insight into how objects are being used, which can help in identifying and fixing bugs.
• Type-safe downcasting: In cases where you need to downcast a base class pointer or reference to a derived class, RTTI can help ensure the cast is safe. By using dynamic_cast, you can verify if the object is indeed of the expected derived type before performing the cast. This can help prevent undefined behavior or crashes resulting from incorrect casting.
• Serialization and deserialization: RTTI can be employed in serialization and deserialization frameworks to store and retrieve the type information of objects. This makes it possible to reconstruct the correct object types during deserialization, enabling you to work with polymorphic or complex class hierarchies.
• Reflection: While C++ does not have built-in reflection capabilities like some other languages, RTTI can be used to implement basic reflection features. For example, you can create a system that associates type information with metadata, allowing you to inspect or manipulate objects and their properties at runtime.
• Variant types: RTTI can be used to implement variant types, which are data structures that can hold values of different types. By storing type information alongside the data, you can perform type-safe operations on the variant, such as extracting the stored value or performing type-specific actions.
• Dynamic loading of plugins: In applications that support plugins or extensions, RTTI can be used to ensure that the dynamically loaded objects are of the correct type. This helps maintain type safety and can prevent crashes or unexpected behavior due to incompatible plugins.
• Implementing scripting languages: When embedding scripting languages in a C++ application, RTTI can be used to expose or manipulate C++ objects and their types within the scripting language. This enables seamless integration between the scripting language and the host application.

These are just a few examples of the many applications of RTTI in C++. By providing runtime type information, RTTI allows for more dynamic, flexible, and error-resistant programs.

Example: A Simple Polymorphic Factory

To illustrate the practical use of RTTI, let’s implement a simple polymorphic factory that creates objects of different types based on their type names.

#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <functional>
#include <typeinfo>

class base {
public:
    virtual ~base() {}
    virtual std::unique_ptr<base> clone() const = 0;
};

class derived_a : public base {
public:
    std::unique_ptr<base> clone() const override {
        return std::make_unique<derived_a>(*this);
    }
};

class derived_b : public base {
public:
    std::unique_ptr<base> clone() const override {
        return std::make_unique<derived_b>(*this);
    }
};

class factory {
public:
    template <typename T>
    void register_type() {
        std::string type_name = typeid(T).name();
        creators[type_name] = []() -> std::unique_ptr<base> {
            return std::make_unique<T>();
        };
    }

    std::unique_ptr<base> create(const std::string& type_name) {
        auto it = creators.find(type_name);
        if (it != creators.end()) {
            return it->second();
        }
        return nullptr;
    }

private:
    std::map<std::string, 
             std::function<std::unique_ptr<base>()>> creators;
};

int main() {
    factory my_factory;
    my_factory.register_type<derived_a>();
    my_factory.register_type<derived_b>();

    std::unique_ptr<base> obj_a = 
         my_factory.create(typeid(derived_a).name());
    std::unique_ptr<base> obj_b = 
         my_factory.create(typeid(derived_b).name());

    if (obj_a) {
        std::cout << "Created object of type: " 
                  << typeid(*obj_a).name() << std::endl;
    }

    if (obj_b) {
        std::cout << "Created object of type: " 
                  << typeid(*obj_b).name() << std::endl;
    }

    return 0;
}

Example output using g++:

$ g++ -std=c++20 3.cpp -o 3

$ ./3 
Created object of type: 9derived_a
Created object of type: 9derived_b

In this example, we implemented a simple polymorphic factory that creates objects of different types based on their type names. The register_type function is a template function that accepts the type of the object to be created and registers a lambda function to create objects of that type. The create function takes the type name as a string and looks up the appropriate creator function in the creators map to create the object. By using RTTI, we can create objects of different types dynamically, allowing for greater flexibility and extensibility in our programs.

Run-Time Type Identification (RTTI) is a powerful feature in C++ that enables us to inspect and manipulate type information at runtime. It has various applications, such as debugging, implementing polymorphic behaviors, and working with template functions and classes. Through the use of typeid and dynamic_cast, we can perform RTTI operations to create more dynamic and flexible programs.