Typically,
RTTI is implemented by placing an additional pointer in the VTABLE.
This pointer points to the
typeinfostructure
for that particular type. (Only one instance of the
typeinfo
structure is created for each new class.) So the effect of a
typeid( )
expression is quite simple: The VPTR is used to fetch the
typeinfo
pointer, and a reference to the resulting
typeinfo
structure is produced. Also, this is a deterministic process – you always
know how long it’s going to take.
For
a
dynamic_cast<destination*>(source_pointer),
most cases are quite straightforward:
source_pointer’s
RTTI information is retrieved, and RTTI information for the type
destination*
is fetched. Then a library routine determines whether
source_pointer’s
type is of type
destination*
or a base class of
destination*.
The pointer it returns may be slightly adjusted because of multiple inheritance
if the base type isn’t the first base of the derived class. The situation
is (of course) more complicated with multiple inheritance where a base type may
appear more than once in an inheritance hierarchy and where virtual base
classes are used.
Because
the library routine used for
dynamic_cast
must check through a list of base classes, the overhead for
dynamic_cast
is higher than
typeid( )
(but of course you get different information, which may be essential to your
solution), and it’s nondeterministic because it may take more time to
discover a base class than a derived class. In addition,
dynamic_cast
allows you to compare any type to any other type; you aren’t restricted
to comparing types within the same hierarchy. This adds extra overhead to the
library routine used by
dynamic_cast.