The simplest form of reflection available in D is runtime type information, which is available through the typeid() operator. It is used extensively by the druntime implementation and is integral to the safe dynamic casting of classes.
Let's execute the following steps to get dynamic runtime type information:
- In most cases, you only need to write
typeid(variable_or_type). - If you want to get a dynamic class type through an interface, first cast it to
Object, check fornull, and then usetypeid(the_casted_object).
The code is as follows:
TypeInfo typeInfoAboutInt = typeid(int); typeInfoAboutInt = typeid(1); // also works
The compiler and the runtime library automatically define type information for all types. This information is found in static TypeInfo objects, which is retrieved by reference using the typeid() operator. The definition of the TypeInfo interface is found in the automatically-imported object.d module of druntime, and thus it is always available to D programs.
TypeInfo is tailored for druntime's needs. It contains functions for:
- Hashing, equality, and comparison (needed for associative arrays).
- Construction, destruction, copying, and garbage collection flags (needed for the
newoperator and built-in array operators). - Getting the next type out of a compound type. For example
, typeid(int*).next is typeid(int).typeid(int*)gives information about a pointer, which points to the next type. - An internal extension hook, intended for future garbage collection improvements.
Classes and interfaces have to get additional functions:
- The class' name
- The class' base class and interfaces
- The class' virtual function table
- The class' initial memory image
- Searching and creating the class, if it has a simple constructor
These methods are vital to the proper functioning of classes. They enable safe dynamic casting from base class to derived class, proper object construction, and automatic implementation of toString, which works without being explicitly overridden in every class you write.
The TypeInfo references are only stored with the data of class objects (specifically, the first hidden virtual function entry for each object stores a reference to the correct TypeInfo reference). With all other types, typeid yields a reference based on the static type. This means that you cannot retrieve the runtime type information from a void* or void[], as shown in the following code:
void main() {
int[] a;
arrayType(a);
}
void arrayType(void[] arr) {
// assert(typeid(arr) == typeid(int[])); // FAILS
// The following passes because non-class typeid is based on static type
assert(typeid(arr) == typeid(void[]));
}If you want to work with void* in a type-safe way, it is important to explicitly pair a TypeInfo object with it. This is how the druntime functions work, also some of the language features' non-template D variadic functions work in the same way.
Tip
Templates are generally better at both type safety and efficiency than runtime information. You should only use TypeInfo based typing in functions when you have special ABI requirements. The void* and TypeInfo pairs are used in druntime primarily for legacy reasons; the library was designed before D had templates.
Static types are also used with interfaces: typeid(some_object_via_interface) and is typeid(the_interface_you_are_using);. In order to get the dynamic type of the object behind the interface, you will have to first cast it to an object, and then cast it from the object to the derived class.
To compare types at runtime, you may use either the == operator or the is operator on TypeInfo. Since there's only one instantiation for each type, you can always rely on the comparison operators.
- Refer to the documentation on
TypeInfo's members at http://dlang.org/phobos/object.html#TypeInfo . Also, scroll down toTypeInfo_Classto see additional members available on classes.