Casting: static vs dynamic

A static_cast takes place at the compilation stage and can prevent compilation errors, but this can result in meaningless runtime events in the context of the wrong object referencing.

The static_cast does not ensure type safety.

The dynamic_cast operator provides a mechanism for testing at runtime whether an object-based cast causes problems.

We know that a base class pointer can point to objects of any derived class.
The dynamic_cast is useful to identify which type, which derived class, of object is pointed to by the base class pointer.

The dynamic_cast operator

The dynamic_cast operator uses similar syntax to the static_cast operator. However, the dynamic_cast operator checks whether a cast is type safe, at runtime. A dynamic_cast is only legal when applied to a polymorphic type.

dynamic_cast<T*>( new P );

... where P must be a polymorphic class, but T doesn’t have to be. The target type of a dynamic_cast, specified in angle brackets, must be a pointer or a reference.

If T is a class, T* and T& and T&& are legal targets but T is not.

class C {
// No virtual methods
};

class T : public C {
};

int main()
{
dynamic_cast<T*>( new C );
}

This fails at compile time because C isn’t polymorphic.

Error: The dynamic_cast operand must be a pointer or reference to a polymorphic type.

The virtual function means C is now polymorphic, so this works.

class C {
public:
virtual void m() {};
};

class T: public C {
// ...
};

int main()
{
dynamic_cast<T*>( new C );
}

If we have a type X, and ptr is a pointer to a polymorphic type, then the expression:

dynamic_cast<X*>( ptr )

evaluates at runtime to:

ptr if the cast is type safe
NULL (false) if the cast is not type safe nullptr for C++11

Type Safety

class B {
public:
virtual void f() { }
};

class D : public B {
public:
void m() { cout << "Test " << endl;}
};

int main()
{
D* p = dynamic_cast<D*>(new B);
if ( p != nullptr ) // <-- dynamic_cast prevents unsafe data casting.
p->m();
else
cerr << "Unsafe for p to point to a B" << endl;
}