C++ Type Casting Operators: static_cast, dynamic_cast, const_cast & reinterpret_cast

Type casting is the mechanism of converting a variable from one data type into another. While implicit conversions happen automatically, explicit conversions require deliberate programmer intent. Modern C++ introduced four explicit casting operators that completely replace dangerous C-style casts.

The 4 Modern C++ Named Casting Operators

Operator	Check Time	Primary Purpose & Safety
`static_cast<T>(v)`	Compile-time	Standard well-defined conversions (e.g. `float` to `int`, base to derived when type is certain). Safest general cast.
`dynamic_cast<T>(v)`	Runtime (RTTI)	Safe downcasting in inheritance hierarchies with virtual functions. Returns `nullptr` on failure.
`const_cast<T>(v)`	Compile-time	Adds or removes `const` or `volatile` qualifiers. (Never modify originally const data!).
`reinterpret_cast<T>(v)`	Compile-time	Low-level reinterpretation of bit patterns (e.g., pointer to integer, int* to char*). Highly dangerous.

Code Demonstration of All 4 Casts

#include <iostream>

class Base { public: virtual ~Base() {} };
class Derived : public Base { public: void shout() { std::cout << "Derived!\n"; } };

int main() {
    // 1. static_cast: Float to Int
    double pi = 3.14159;
    int intPi = static_cast<int>(pi); // 3

    // 2. dynamic_cast: Polymorphic runtime validation
    Base* b = new Derived();
    if (Derived* d = dynamic_cast<Derived*>(b)) {
        d->shout(); // Safe: cast succeeded!
    }
    delete b;

    // 3. const_cast: Calling legacy API requiring non-const pointer
    const int val = 100;
    const int* ptr = &val;
    int* modifiablePtr = const_cast<int*>(ptr);

    return 0;
}

Frequently Asked Questions (FAQ) - Student & Interview Review

Q1. Why does modern C++ forbid C-style casting (e.g. (int)x)?

C-style casts are dangerous because they blindly attempt static_cast, const_cast, and reinterpret_cast without compiler safety checks. Named C++ casts (like static_cast) clearly communicate intent, catch invalid conversions at compile time, and are easily searchable in large codebases.

Q2. When must dynamic_cast be used instead of static_cast?

dynamic_cast is used for safe downcasting in polymorphic class hierarchies (classes with at least one virtual function). It checks Run-Time Type Information (RTTI) and returns nullptr (or throws std::bad_cast for references) if the cast is invalid.