C++ Casts and Type Conversions

# CHAPTER 27

C++ Casts and Type Conversions #

1. Introduction #

2. Learning Objectives #

• Explain the danger of C-Style casts.

• Use staticcast for safe, ordinary conversions.

• Use dynamiccast for safe polymorphism.

• Understand constcast and reinterpretcast.

3. The Danger of C-Style Casts #

4. static_cast (The Workhorse) #

#include <iostream>
using namespace std;

int main() {
    float pi = 3.14159f;
    
    // C-Style (Avoid in C++)
    int c_cast = (int)pi; 
    
    // Modern C++ Style (Preferred)
    int cpp_cast = static_cast<int>(pi); 
    
    cout << cpp_cast << endl; // Prints 3
    
    return 0;
}

5. dynamiccast (Safe Downcasting) #

dynamiccast checks at *runtime* if the downcast is valid. If it fails, it returns nullptr.

class Base { public: virtual void dummy() {} };
class Derived : public Base { public: void doDerivedWork() {} };

int main() {
    Base* basePtr = new Derived(); // Upcast (Safe)
    
    // Safe Downcast
    Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);
    
    if (derivedPtr != nullptr) {
        cout << "Cast successful!" << endl;
        derivedPtr->doDerivedWork();
    } else {
        cout << "Cast failed!" << endl;
    }
    
    return 0;
}

6. const_cast #

void legacyFunction(int* ptr) {
    // Some old code
}

int main() {
    const int val = 10;
    
    // legacyFunction(&val); // ERROR! Cannot pass const int* to int*
    
    legacyFunction(const_cast<int*>(&val)); // Works! (But dangerous if the function modifies it)
    
    return 0;
}

7. reinterpret_cast #

int main() {
    long long address = 0x7ffee123;
    
    // Forcing an integer to be treated as a memory address!
    int* ptr = reinterpret_cast<int*>(address); 
    
    return 0;
}

8. Memory-Level Explanation #

• staticcast may actually alter the binary data (e.g., converting float 3.14 to integer 3 requires completely changing the binary structure).

• reinterpretcast leaves the binary data exactly as it is, but changes the "lens" through which the compiler reads that data.

9. Common Mistakes #

• Using dynamiccast on classes without virtual functions: dynamiccast relies on the VTable (Virtual Table) to determine the object type at runtime (RTTI - Run-Time Type Information). If there are no virtual functions, there is no VTable, and the compiler will throw an error.

• Using C-style casts: If you type (int)x, the compiler attempts a staticcast. If that fails, it secretly tries a reinterpretcast. This hidden fallback behavior is exactly why C-style casts cause untraceable bugs.

10. Exercises #

1. 1. Write a program that asks for two integers, uses staticcast<double> to perform a floating-point division, and prints the result.

1. 2. Create an inheritance hierarchy (Animal -> Dog) with a virtual function. Create an Animal* pointing to a new Animal(). Try to dynamiccast it to a Dog* and print whether it succeeded or returned nullptr.

11. MCQ Quiz with Answers #

• Q: How does dynamiccast know what the object type actually is at runtime? (Answer: RTTI - Run-Time Type Information).

• Q: Why is modifying a variable after using constcast considered Undefined Behavior?

14. Next Chapter Recommendation #