Pointers to polymorphic objects (objects of classes which define at
least one virtual function) are sometimes downcast or crosscast.
Downcasting means casting from a base class to a derived class.
Crosscasting means casting across an inheritance hierarchy diagram, such
as from one base to the other in a Y diagram hierarchy.

Such casts can be done with old-style casts, but this approach is
never to be recommended. Old-style casts are sorely lacking in type
safety, suffer poor readability, and are difficult to locate with search
tools.

The C++ built-in static_cast can be used for efficiently
downcasting pointers to polymorphic objects, but provides no error
detection for the case where the pointer being cast actually points to
the wrong derived class. The polymorphic_downcast template retains
the efficiency of static_cast for non-debug compilations, but for
debug compilations adds safety via an assert() that a dynamic_cast
succeeds.

The C++ built-in dynamic_cast can be used for downcasts and
crosscasts of pointers to polymorphic objects, but error notification in
the form of a returned value of 0 is inconvenient to test, or worse yet,
easy to forget to test. The throwing form of dynamic_cast, which
works on references, can be used on pointers through the ugly expression
&dynamic_cast<T&>(*p), which causes undefined
behavior if p is 0. The polymorphic_cast
template performs a dynamic_cast on a pointer, and throws an
exception if the dynamic_cast returns 0.

A polymorphic_downcast should be used for
downcasts that you are certain should succeed. Error checking is
only performed in translation units where NDEBUG is
not defined, via

assert( dynamic_cast<Derived>(x) == x )

where x is the source pointer. This approach
ensures that not only is a non-zero pointer returned, but also
that it is correct in the presence of multiple inheritance.
Attempts to crosscast using polymorphic_downcast will
fail to compile.
Warning: Because polymorphic_downcast uses assert(), it
violates the One Definition Rule (ODR) if NDEBUG is inconsistently
defined across translation units. [See ISO Std 3.2]

For crosscasts, or when the success of a cast can only be known at
runtime, or when efficiency is not important,
polymorphic_cast is preferred.

The C++ built-in dynamic_cast must be used to cast references
rather than pointers. It is also the only cast that can be used to check
whether a given interface is supported; in that case a return of 0 isn't
an error condition.