dynamic_cast and safe downcasting

Understanding dynamic_cast and safe downcasting

A pointer's static type is what you promised the compiler; the object's dynamic type is what actually got constructed. static_cast<Derived*>(base) adjusts the address using only the declared types and asks no questions, so if the object is not really a Derived you get a pointer into memory that never held one, and every use of it is undefined behaviour. dynamic_cast instead follows the object's vptr to the runtime type information the compiler emitted for the most-derived class, checks whether that object truly contains a Derived subobject, and only then hands back the adjusted address. That check is exactly why dynamic_cast requires a polymorphic source type: with no virtual function there is no vptr, nothing connects those bytes to a type, and the cast is rejected at compile time.

There are two forms because there are two sensible reactions to failure. The pointer form returns nullptr, which is why the idiomatic shape is a cast written inside an if condition: the conversion and the test happen once, and the derived pointer is only in scope in the branch where it is valid. The reference form has no null reference to return, so it throws std::bad_cast; reach for it when a mismatch means your assumptions are already broken and you want a loud, catchable failure instead of a silently skipped branch.

The useful mental model is that dynamic_cast interrogates the object, not the pointer: the answer depends only on which constructor ran, never on the type of the handle you happen to hold. Because the runtime knows the layout of the whole most-derived object, it can also cross-cast sideways from one base subobject to an unrelated sibling base of the same object, and it corrects the address when those subobjects live at different offsets, so the numeric pointer value can change. The flip side is cost and design: a failed cast may have to walk the inheritance graph, and a long if-else chain of dynamic_casts over a fixed set of derived classes is usually a virtual function nobody wrote.

#include <iostream>
#include <typeinfo>

struct Shape {
    virtual ~Shape() = default;
    virtual double area() const = 0;
};

struct Circle : Shape {
    double radius;
    explicit Circle(double r) : radius(r) {}
    double area() const override { return 3.14159 * radius * radius; }
    void printRadius() const { std::cout << "radius " << radius << '\n'; }
};

struct Square : Shape {
    double side;
    explicit Square(double s) : side(s) {}
    double area() const override { return side * side; }
};

void inspect(const Shape& shape) {
    if (const Circle* c = dynamic_cast<const Circle*>(&shape)) {
        std::cout << "circle: ";
        c->printRadius();
    } else {
        std::cout << "some other shape, area " << shape.area() << '\n';
    }
}

int main() {
    Circle circle(2.0);
    Square square(3.0);

    inspect(circle);
    inspect(square);

    const Shape& asShape = square;
    try {
        const Circle& c = dynamic_cast<const Circle&>(asShape);
        std::cout << "unreachable " << c.radius << '\n';
    } catch (const std::bad_cast&) {
        std::cout << "reference form threw std::bad_cast\n";
    }
}

Worked examples

#include <iostream>

struct Drawable {
    virtual ~Drawable() = default;
    virtual void draw() const = 0;
};

struct Serializable {
    virtual ~Serializable() = default;
    virtual void save() const = 0;
};

struct Sprite : Drawable, Serializable {
    void draw() const override { std::cout << "draw sprite\n"; }
    void save() const override { std::cout << "save sprite\n"; }
};

struct Cursor : Drawable {
    void draw() const override { std::cout << "draw cursor\n"; }
};

void render(const Drawable& d) {
    d.draw();
    if (const Serializable* s = dynamic_cast<const Serializable*>(&d)) {
        s->save();
    } else {
        std::cout << "nothing to save\n";
    }
}

int main() {
    Sprite sprite;
    Cursor cursor;
    render(sprite);
    render(cursor);
}

#include <iostream>

struct Base {
    Base();
    virtual ~Base() = default;
    void report(const char* when) const;
};

struct Derived : Base {
    Derived() { report("in Derived ctor body"); }
};

Base::Base() { report("in Base ctor body"); }

void Base::report(const char* when) const {
    std::cout << when << ": "
              << (dynamic_cast<const Derived*>(this) ? "is Derived" : "not Derived")
              << '\n';
}

int main() {
    Derived d;
    d.report("after construction");
}

Important notes

Common mistakes

Try it yourself