The Four C++ Cast Operators

std::cout << "=== 1. static_cast ===\n\n";

    // --- 1a. Numeric conversions ---
    std::cout << "--- 1a. Numeric conversions ---\n";
    int whole = 42;
    double precise = static_cast<double>(whole);
    std::cout << std::format("  int {} -> double {:.1f}\n", whole, precise);

    double pi = 3.14159;
    int truncated = static_cast<int>(pi);
    std::cout << std::format("  double {:.5f} -> int {} (truncated, NOT rounded)\n",
                              pi, truncated);

    // Without the cast, the compiler warns about narrowing.
    // static_cast silences the warning AND documents your intent.
    // Compare:
    //   int x = pi;                  // warning: implicit narrowing
    //   int x = static_cast<int>(pi); // explicit: "I know I'm truncating"

    // --- 1b. Enum conversions ---
    std::cout << "\n--- 1b. Enum conversions ---\n";
    enum class Color { Red, Green, Blue };
    Color c = Color::Green;
    int color_value = static_cast<int>(c);
    std::cout << std::format("  Color::Green = {}\n", color_value);

    // And back from int to enum (useful when reading from files/network)
    Color restored = static_cast<Color>(2);
    std::cout << std::format("  static_cast<Color>(2) == Color::Blue? {}\n",
                              restored == Color::Blue);

    // --- 1c. void* to typed pointer ---
    std::cout << "\n--- 1c. void* to typed pointer ---\n";
    SensorData sensor{22.5, 65.0};
    void* raw_ptr = &sensor;  // Any pointer implicitly converts to void*
    // Getting it back requires a cast:
    auto* typed_ptr = static_cast<SensorData*>(raw_ptr);
    std::cout << std::format("  Temperature: {:.1f}°C\n", typed_ptr->temperature);

    // --- 1d. Class hierarchy upcast / downcast ---
    std::cout << "\n--- 1d. Hierarchy casts ---\n";
    Dog rex("Rex");
    // Upcast: Dog* -> Animal* (always safe, implicit, but can be explicit)
    Animal* animal_ptr = static_cast<Animal*>(&rex);
    std::cout << std::format("  Upcast: {} says {}\n",
                              animal_ptr->name(), animal_ptr->speak());

    // Downcast: Animal* -> Dog* (safe here because we KNOW it's a Dog)
    Dog* dog_ptr = static_cast<Dog*>(animal_ptr);
    dog_ptr->fetch();
    // If animal_ptr pointed to a Cat, this would be undefined behavior!
    // Use dynamic_cast when unsure.

std::cout << "\n=== 2. dynamic_cast ===\n\n";

    // Create animals and store as base pointers (common pattern)
    std::unique_ptr<Animal> animals[] = {
        std::make_unique<Dog>("Buddy"),
        std::make_unique<Cat>("Whiskers"),
        std::make_unique<Dog>("Max"),
    };

    // --- 2a. Pointer form: returns nullptr on failure ---
    std::cout << "--- 2a. Pointer form (nullptr on failure) ---\n";
    for (const auto& animal : animals) {
        std::cout << std::format("  {} says: {}\n",
                                  animal->name(), animal->speak());

        // Try to downcast to Dog*
        if (Dog* dog = dynamic_cast<Dog*>(animal.get())) {
            // This block ONLY executes if animal is actually a Dog.
            // The pattern "if (auto* p = dynamic_cast<T*>(expr))" is
            // idiomatic C++ — the variable is scoped to the if block.
            dog->fetch();
        }

        // Try to downcast to Cat*
        if (Cat* cat = dynamic_cast<Cat*>(animal.get())) {
            cat->purr();
        }
    }

    // --- 2b. Reference form: throws std::bad_cast on failure ---
    std::cout << "\n--- 2b. Reference form (throws on failure) ---\n";
    Dog buddy("Buddy");
    Animal& animal_ref = buddy;

    try {
        // We know this will succeed, but demonstrating the syntax
        Dog& dog_ref = dynamic_cast<Dog&>(animal_ref);
        std::cout << std::format("  Successfully cast {} to Dog&\n", dog_ref.name());

        // This will throw because buddy is a Dog, not a Cat
        [[maybe_unused]] Cat& cat_ref = dynamic_cast<Cat&>(animal_ref);
    } catch (const std::bad_cast& e) {
        std::cout << std::format("  bad_cast: {} (expected — it's a Dog, not a Cat)\n",
                                  e.what());
    }

    // --- 2c. Cross-casting (multiple inheritance) ---
    // dynamic_cast can also cast between sibling bases in a multiple
    // inheritance hierarchy — something static_cast CANNOT do.
    // We won't demo multiple inheritance here, but know that it's
    // one of dynamic_cast's unique capabilities.

std::cout << "\n=== 3. const_cast ===\n\n";

    // --- 3a. Calling a legacy API ---
    std::cout << "--- 3a. Legacy C API interop ---\n";
    const std::string message = "Hello from const string";
    safe_legacy_print(message);
    // The string was not modified — const_cast was safe here because
    // legacy_print only reads the data.

    // --- 3b. Avoiding code duplication in const/non-const overloads ---
    std::cout << "\n--- 3b. const/non-const overload pattern ---\n";
    // A class that returns const or non-const access to internal data:
    struct TextBuffer {
        std::string data = "Hello, World!";

        // The const version — does the real work
        const char& char_at(std::size_t i) const {
            // Bounds checking, logging, etc. would go here
            return data[i];
        }

        // The non-const version — delegates to const version to avoid
        // duplicating the bounds-checking logic
        char& char_at(std::size_t i) {
            // 1. Cast 'this' to const to call the const overload
            // 2. const_cast the result back to non-const
            // This is safe because we KNOW 'this' is actually non-const
            // (otherwise the non-const overload wouldn't have been called)
            return const_cast<char&>(
                static_cast<const TextBuffer&>(*this).char_at(i)
            );
        }
    };

    TextBuffer buf;
    buf.char_at(0) = 'J';  // Uses non-const overload
    std::cout << std::format("  Modified buffer: {}\n", buf.data);

    const TextBuffer cbuf;
    char ch = cbuf.char_at(0);  // Uses const overload
    std::cout << std::format("  Const buffer first char: {}\n", ch);

    // --- 3c. DANGER: modifying a truly-const object ---
    // const int original_const = 42;
    // int* bad_ptr = const_cast<int*>(&original_const);
    // *bad_ptr = 99;  // UNDEFINED BEHAVIOR! original_const may be in ROM
    // Don't do this. Ever.
    std::cout << "\n  (Skipping UB demo — modifying a true const is undefined behavior)\n";

std::cout << "\n=== 4. reinterpret_cast ===\n\n";

    // --- 4a. Viewing raw bytes of a value (the safe char* exception) ---
    std::cout << "--- 4a. Viewing raw bytes ---\n";
    float value = 3.14f;
    // Casting to unsigned char* is explicitly allowed by the standard
    auto* bytes = reinterpret_cast<unsigned char*>(&value);
    std::cout << std::format("  float {:.2f} in memory: ", value);
    for (std::size_t i = 0; i < sizeof(float); ++i) {
        std::cout << std::format("{:02x} ", bytes[i]);
    }
    std::cout << '\n';
    // This is how debuggers, serializers, and network code inspect
    // the raw representation of values.

    // --- 4b. Integer <-> pointer (system programming) ---
    std::cout << "\n--- 4b. Integer <-> pointer ---\n";
    int some_value = 42;
    auto address = reinterpret_cast<std::uintptr_t>(&some_value);
    std::cout << std::format("  Address of some_value: {:#x}\n", address);
    // Going back from integer to pointer (useful for hardware registers):
    auto* back_to_ptr = reinterpret_cast<int*>(address);
    std::cout << std::format("  Value at that address: {}\n", *back_to_ptr);
    // This round-trip is guaranteed to work by the standard for uintptr_t.

    // --- 4c. Passing through a C void* callback ---
    std::cout << "\n--- 4c. void* callback (C API pattern) ---\n";
    SensorData reading{23.5, 70.0};
    // C APIs commonly use void* for user data in callbacks
    process_raw_data(&reading, 1);