In computer programming, run-time type information or run-time type identification (RTTI) refers to a C++ mechanism that exposes information about an object's data type at runtime. Run-time type information can apply to simple data types, such as integers and characters, or to generic types. This is a C++ specialization of a more general concept called type introspection. Similar mechanisms are also known in other programming languages, such as Object Pascal (Delphi).
In the original C++ design, Bjarne Stroustrup did not include run-time type information, because he thought this mechanism was often misused.
Video Run-time type information
Overview
C++ RTTI can be used to do safe typecasts, using the dynamic_cast<>
operator, and to manipulate type information at run time, using the typeid
operator and std::type_info
class.
RTTI is available only for classes which are polymorphic, which means they have at least one virtual method. In practice, this is not a limitation because base classes must have a virtual destructor to allow objects of derived classes to perform proper cleanup if they are deleted from a base pointer.
RTTI is optional with some compilers; the programmer can choose at compile time whether to include the functionality. There may be a resource cost to making RTTI available even if a program does not use it.
Maps Run-time type information
typeid
The typeid
keyword is used to determine the class of an object at run time. It returns a reference to std::type_info
object, which exists until the end of the program. The use of typeid
, in a non-polymorphic context, is often preferred over dynamic_cast<class_type>
in situations where just the class information is needed, because typeid
is a constant-time procedure, whereas dynamic_cast
must traverse the class derivation lattice of its argument at runtime. Some aspects of the returned object are implementation-defined, such as std::type_info::name()
, and cannot be relied on across compilers to be consistent.
Objects of class std::bad_typeid
are thrown when the expression for typeid
is the result of applying the unary * operator on a null pointer. Whether an exception is thrown for other null reference arguments is implementation-dependent. In other words, for the exception to be guaranteed, the expression must take the form typeid(*p)
where p
is any expression resulting in a null pointer.
Example
Output (exact output varies by system):
Person Employee Person* Employee Employee
dynamic_cast and Java cast
The dynamic_cast
operator in C++ is used for downcasting a reference or pointer to a more specific type in the class hierarchy. Unlike the static_cast
, the target of the dynamic_cast
must be a pointer or reference to class. Unlike static_cast
and C-style typecast (where type check is made during compilation), a type safety check is performed at runtime. If the types are not compatible, an exception will be thrown (when dealing with references) or a null pointer will be returned (when dealing with pointers).
A Java typecast behaves similarly; if the object being cast is not actually an instance of the target type, and cannot be converted to one by a language-defined method, an instance of java.lang.ClassCastException
will be thrown.
Example
Suppose some function takes an object of type A
as its argument, and wishes to perform some additional operation if the object passed is an instance of B
, a subclass of A
. This can be accomplished using dynamic_cast
as follows.
Console output:
Method specific for B was invoked Method specific for B was invoked Exception std::bad_cast thrown. Object is not of type B
A similar version of my_function
can be written with pointers instead of references:
See also
- Template (C++)
- Reflection (computer science)
References
External links
dynamic_cast
operator at IBM Mac OS X Compilersdynamic_cast
operator at MSDN
Source of the article : Wikipedia