dynamic_cast conversion

Safely converts pointers and references to classes up, down, and sideways along the inheritance hierarchy.

Syntax

Explanation

For the convenience of description, “expression or the result is a reference to T” means that “it is a glvalue of type T”, which follows the convention of decltype(since C++11)

Only the following conversions can be done with dynamic_cast, except when such conversions would cast away constness

When dynamic_cast is used in a constructor or a destructor (directly or indirectly), and expression refers to the object that's currently under construction/destruction, the object is considered to be the most derived object. If target-type

1. ↑ In other words, dynamic_cast can be used to add constness. An implicit conversion and static_cast
2. ↑ ^{2.0 2.1} An implicit conversion and static_cast can perform this conversion as well.
3. ↑ This is known as a “downcast”.
4. ↑ This is known as a “sidecast”.

Similar to other cast expressions, the result is:

Notes

A downcast can also be performed with static_cast, which avoids the cost of the runtime check, but it is only safe if the program can guarantee (through some other logic) that the object pointed to by expression is definitely Derived

Some forms of dynamic_cast rely on run-time type identification

Keywords

dynamic_cast

Example

#include <iostream>
 
struct V
{
    virtual void f() {} // must be polymorphic to use runtime-checked dynamic_cast
};
 
struct A : virtual V {};
 
struct B : virtual V
{
    B(V* v, A* a)
    {
        // casts during construction (see the call in the constructor of D below)
        dynamic_cast<B*>(v); // well-defined: v of type V*, V base of B, results in B*
        dynamic_cast<B*>(a); // undefined behavior: a has type A*, A not a base of B
    }
};
 
struct D : A, B
{
    D() : B(static_cast<A*>(this), this) {}
};
 
struct Base
{
    virtual ~Base() {}
};
 
struct Derived : Base
{
    virtual void name() {}
};
 
int main()
{
    D d; // the most derived object
    A& a = d; // upcast, dynamic_cast may be used, but unnecessary
 
    [[maybe_unused]]
    D& new_d = dynamic_cast<D&>(a); // downcast
    [[maybe_unused]]
    B& new_b = dynamic_cast<B&>(a); // sidecast
 
    Base* b1 = new Base;
    if (Derived* d = dynamic_cast<Derived*>(b1); d != nullptr)
    {
        std::cout << "downcast from b1 to d successful\n";
        d->name(); // safe to call
    }
 
    Base* b2 = new Derived;
    if (Derived* d = dynamic_cast<Derived*>(b2); d != nullptr)
    {
        std::cout << "downcast from b2 to d successful\n";
        d->name(); // safe to call
    }
 
    delete b1;
    delete b2;
}

downcast from b2 to d successful

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

References

See also

• const_cast
• static_cast
• reinterpret_cast
• explicit cast
• implicit conversions