typeid Operator

The typeid operator allows the type of an object to be determined at run time.

Syntax

typeid( type-id )

typeid( expression )

The result of a typeid expression is a const type_info&. The value is a reference to a type_info object that represents either the type-id or the type of the expression, depending on which form of typeid is used. See type_info Class for more information.

The typeid operator does a run-time check when applied to an l-value of a polymorphic class type, where the true type of the object cannot be determined by the static information provided. Such cases are:

• A reference to a class
  
  
• A pointer, dereferenced with *
  
  
• A subscripted pointer (i.e. [ ]). (Note that it is generally not safe to use a subscript with a pointer to a polymorphic type.)

If the expression points to a base class type, yet the object is actually of a type derived from that base class, a type_info reference for the derived class is the result. The expression must point to a polymorphic type, that is, a class with virtual functions. Otherwise, the result is the type_info for the static class referred to in the expression. Further, the pointer must be dereferenced so that the object it points to is used. Without dereferencing the pointer, the result will be the type_info for the pointer, not what it points to. For example:

class Base { ... };

class Derived : public Base { ... };

void f()
{
   Derived* pd = new Derived;
   Base* pb = pd;
   ...
   const type_info& t = typeid(pb);      // t holds pointer type_info
   const type_info& t1 = typeid(*pb);      // t1 holds Derived info
   ...
}

If the expression is dereferencing a pointer, and that pointer’s value is zero, typeid throws a bad_typeid exception. If the pointer does not point to a valid object, a __non_rtti_object exception is thrown.

If the expression is neither a pointer nor a reference to a base class of the object, the result is a type_info reference representing the static type of the expression.