> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C++ Dynamic Cast `dynamic_cast` is a type conversion operator in C++ used primarily for safe, runtime downcasting and cross-casting within a polymorphic class hierarchy. It leverages Run-Time Type Information (RTTI) to inspect the virtual method table (vtable) and verify the validity of the cast during program execution. ## Syntax ```cpp theme={"dark"} dynamic_cast(expression) ``` * **`new_type`**: Must be a pointer or a reference to a complete class type, or a pointer to `void` (`void*`). * **`expression`**: * If `new_type` is a pointer, `expression` must be a pointer to a complete class type. * If `new_type` is an lvalue reference, `expression` must be an lvalue of a complete class type. * If `new_type` is an rvalue reference, `expression` must be a glvalue or a prvalue of a complete class type (where a prvalue undergoes temporary materialization). ## Technical Requirements 1. **Polymorphism**: For downcasting (base to derived) or cross-casting (between sibling base classes in multiple inheritance), the source type of `expression` **must** be polymorphic. This means the base class must declare or inherit at least one `virtual` function (typically a virtual destructor). Attempting a runtime `dynamic_cast` on a non-polymorphic type results in a compilation error. 2. **RTTI**: The compiler must have RTTI enabled to perform runtime type checks. If RTTI is disabled via compiler flags (e.g., `-fno-rtti` in GCC/Clang), `dynamic_cast` will fail to compile *only* when used for downcasting or cross-casting. Upcasting will still compile successfully without RTTI. ## Execution Behavior and Failure Modes The behavior of `dynamic_cast` depends strictly on whether `new_type` is a pointer or a reference. The following examples assume this polymorphic class hierarchy: ```cpp theme={"dark"} class Base { public: virtual ~Base() = default; // Ensures Base is polymorphic }; class Derived : public Base {}; ``` ### 1. Pointer Casting When casting pointers, `dynamic_cast` checks if the dynamic type of the object pointed to by `expression` is a complete object of `new_type` (or derived from it). * **Success**: Returns a valid pointer of type `new_type`. * **Failure**: Returns a null pointer (`nullptr`) of type `new_type`. It does not throw an exception. ```cpp theme={"dark"} Base* basePtr = new Base(); // Fails at runtime: basePtr points to a Base object, not a Derived object Derived* derivedPtr = dynamic_cast(basePtr); if (derivedPtr == nullptr) { // Cast failed gracefully } delete basePtr; ``` ### 2. Reference Casting Because C++ references cannot be null, `dynamic_cast` handles reference casting failures via the C++ exception handling mechanism. * **Success**: Returns a valid reference of type `new_type`. * **Failure**: Throws an exception of type `std::bad_cast`. ```cpp theme={"dark"} #include // Required for std::bad_cast Base baseObj; try { // Fails at runtime: throws std::bad_cast Derived& derivedRef = dynamic_cast(baseObj); } catch (const std::bad_cast& e) { // Cast failed } ``` ### 3. Void Pointer Casting If `new_type` is `void*`, `dynamic_cast` determines the exact dynamic type of the object and returns a pointer to the most derived object (the complete object) pointed to by `expression`. ```cpp theme={"dark"} Base* basePtr = new Derived(); // Points to the start of the complete Derived object void* completeObjPtr = dynamic_cast(basePtr); delete basePtr; ``` ## Compile-Time vs. Runtime Resolution While `dynamic_cast` is known as a runtime cast, it does not always incur runtime overhead: * **Upcasting (Derived to Base)**: If `new_type` is an accessible, unambiguous base class of the type of `expression`, `dynamic_cast` resolves entirely at compile-time. In this scenario, it behaves identically to `static_cast`, does not require the base class to be polymorphic, and does not require RTTI. * **Downcasting / Cross-casting**: Requires runtime resolution. The operator traverses the inheritance graph stored in the RTTI to determine if the target type is a valid cast for the current dynamic object.

Tired of Poor C++ Skills? Fix That With Deep Grasping! Learn More