Run-time type information

From Wikipedia, the free encyclopedia

This article may require cleanup to meet Wikipedia's quality standards.
Please improve this article if you can. (March 2007)

In programming, RTTI (Runtime Type Information, or Runtime Type Identification) means keeping information about an object's data type in memory at runtime. Run-time type information can apply to simple data types, such as integers and characters, or to generic objects.

In the case of objects, some implementations are limited to keeping the inheritance tree while others include information about objects' methods and attributes.

Although available in several computer languages, RTTI, as a term, is typically used in relation to C++. In order for the dynamic_cast<> operation, the typeid operator or exceptions to work in C++, RTTI must be enabled.

[edit] Example in C++

/* A base class pointer can point to objects of any class which is derived 
 * from it. RTTI is useful to identify which type (derived class) of object is 
 * pointed by a base class pointer.
 */
 
#include <iostream>
 
class abc   // base class
{
public:
  virtual void hello() 
  {
    std::cout << "in abc";
  }
};
 
class xyz : public abc
{
  public:
  void hello() 
  {
    std::cout << "in xyz";
  }
};
 
int main()
{
  abc *abc_pointer = new xyz();
  xyz *xyz_pointer;
 
  // to find whether abc is pointing to xyz type of object
  xyz_pointer = dynamic_cast<xyz*>(abc_pointer);
 
  if (xyz_pointer != NULL)
    std::cout << "abc pointer is pointing to a xyz class object";   // identified
  else
    std::cout << "abc pointer is NOT pointing to a xyz class object";
 
  delete abc_pointer;
 
  return 0;
}

An instance where RTTI is used is illustrated below:

class base {
  virtual ~base(){}
};
 
class derived : public base {
  public:
    virtual ~derived(){}
    int compare (derived &ref);
};
 
int my_comparison_method_for_generic_sort (base &ref1, base &ref2)
{
  derived & d = dynamic_cast<derived &>(ref1); // rtti used here
  // RTTI enables the process to throw a bad_cast exception
  // if the cast is not successful
  return d.compare (dynamic_cast<derived &>(ref2));
}