RTTI -Notes - dynamic_cast

Runtime Type Information (RTTI) is the concept of determining the type of any variable during execution (runtime.) The RTTI mechanism contains:

• The operator dynamic_cast
• The operator typeid
• The struct type_info 

Dynamic_cast

The dynamic_cast can only be used with pointers and references to objects. It makes sure that the result of the type conversion is valid and complete object of the requested class. This is way a dynamic_cast will always be successful if we use it to cast a class to one of its base classes. Take a look at the example:

 class Base_Class { };
 class Derived_Class: public Base_Class { };

 Base_Class a; Base_Class * ptr_a;
 Derived_Class b; Derived_Class * ptr_b;

 ptr_a = dynamic_cast<Base_Class *>(&b);
 ptr_b = dynamic_cast<Derived_Class *>(&a);

The first dynamic_cast statement will work because we cast from derived to base. The second dynamic_cast statement will produce a compilation error because base to derived conversion is not allowed with dynamic_cast unless the base class is polymorphic.
If a class is polymorphic then dynamic_cast will perform a special check during execution. This check ensures that the expression is a valid and complete object of the requested class.
Take a look at the example:

// dynamic_cast
#include <iostream>
#include <exception>
using namespace std;

class Base_Class { virtual void dummy() {} };
class Derived_Class: public Base_Class { int a; };

int main () {
  try {
  Base_Class * ptr_a = new Derived_Class;
  Base_Class * ptr_b = new Base_Class;
  Derived_Class * ptr_c;

     ptr_c = dynamic_cast< Derived_Class *>(ptr_a);
     if (ptr_c ==0) cout << "Null pointer on first type-cast" << endl;

     ptr_c = dynamic_cast< Derived_Class *>(ptr_b);
     if (ptr_c ==0) cout << "Null pointer on second type-cast" << endl;

   } catch (exception& my_ex) {cout << "Exception: " << my_ex.what();}
  return 0;
}

In the example we perform two dynamic_casts from pointer objects of type Base_Class* (namely ptr_a and ptr_b) to a pointer object of type Derived_Class*.
If everything goes well then the first one should be successful and the second one will fail. The pointers ptr_a and ptr_b are both of the type Base_Class. The pointer ptr_a points to an object of the type Derived_Class. The pointer ptr_b points to an object of the type Base_Class. So when the dynamic type cast is performed then ptr_a is pointing to a full object of class Derived_Class, but the pointer ptr_b points to an object of class Base_Class. This object is an incomplete object of class Derived_Class; thus this cast will fail!
Because this dynamic_cast fails a null pointer is returned to indicate a failure. When a reference type is converted with dynamic_cast and the conversion fails then there will be an exception thrown out instead of the null pointer. The exception will be of the type bad_cast.
With dynamic_cast it is also possible to cast null pointers even between the pointers of unrelated classes.
Dynamic_cast can cast pointers of any type to void pointer(void*).