Type Casting in C++ Explained: static_cast, dynamic_cast, and When to Use Each

#include <iostream>

int main() {
    // --- IMPLICIT CONVERSION (compiler handles this silently) ---
    int sensorRawReading = 42;
    double calibratedTemperature = sensorRawReading; // int -> double: safe, no data loss
    std::cout << "Calibrated temperature: " << calibratedTemperature << "\n"; // 42.0

    // --- IMPLICIT NARROWING (data loss — compiler may warn, but won't always stop you) ---
    double preciseVoltage = 3.987;
    int roundedVoltage = preciseVoltage; // truncates .987 silently — dangerous!
    std::cout << "Rounded voltage (implicit): " << roundedVoltage << "\n"; // 3, not 4

    // --- EXPLICIT CAST (you own this decision) ---
    // Using static_cast makes the truncation visible to every future reader
    int intentionallyTruncated = static_cast<int>(preciseVoltage);
    std::cout << "Intentionally truncated: " << intentionallyTruncated << "\n"; // 3

    // --- WHY THIS MATTERS ---
    // Both roundedVoltage and intentionallyTruncated produce the same result,
    // but static_cast is greppable, reviewable, and signals intent clearly.
    // A linter or code review can flag all static_casts for inspection.
    // A silent implicit narrowing hides in plain sight.

    return 0;
}

#include <iostream>

// A simple class hierarchy to demonstrate casting direction
class Vehicle {
public:
    virtual ~Vehicle() = default;
    void describe() const { std::cout << "I am a vehicle\n"; }
};

class ElectricCar : public Vehicle {
public:
    void chargeBattery() const { std::cout << "Charging battery to 100%\n"; }
};

int main() {
    // --- USE CASE 1: Numeric conversion ---
    double fuelEfficiency = 14.75; // litres per 100km
    // We want the integer part only for a coarse display
    int coarseEfficiency = static_cast<int>(fuelEfficiency); // truncates, does NOT round
    std::cout << "Coarse efficiency: " << coarseEfficiency << " L/100km\n";

    // --- USE CASE 2: Fixing integer division ---
    int totalDistance = 350; // km
    int numberOfTrips = 4;
    // Without cast: integer division loses the decimal
    double wrongAverage = totalDistance / numberOfTrips;
    // With cast: promotes left operand to double before division
    double correctAverage = static_cast<double>(totalDistance) / numberOfTrips;
    std::cout << "Wrong average: " << wrongAverage << " km\n";   // 87
    std::cout << "Correct average: " << correctAverage << " km\n"; // 87.5

    // --- USE CASE 3: Upcast (Derived -> Base) — always safe ---
    ElectricCar myTesla;
    Vehicle& vehicleRef = myTesla; // implicit upcast — no cast needed, shown for clarity
    vehicleRef.describe();

    // --- USE CASE 4: Downcast (Base -> Derived) — you MUST know the actual type ---
    // Only do this if you are 100% certain vehicleRef actually holds an ElectricCar.
    // If you're not certain, use dynamic_cast (see next section).
    ElectricCar& carRef = static_cast<ElectricCar&>(vehicleRef);
    carRef.chargeBattery(); // safe here because we KNOW myTesla is an ElectricCar

    return 0;
}

#include <iostream>
#include <vector>
#include <memory>

// Base class MUST have at least one virtual function for dynamic_cast to work
class Shape {
public:
    virtual ~Shape() = default;
    virtual void draw() const = 0;
};

class Circle : public Shape {
public:
    void draw() const override { std::cout << "Drawing circle\n"; }
    // Circle-specific method not in the base class
    void setRadius(double r) { radius = r; }
    double getRadius() const { return radius; }
private:
    double radius = 1.0;
};

class Rectangle : public Shape {
public:
    void draw() const override { std::cout << "Drawing rectangle\n"; }
    void setWidth(double w) { width = w; }
    double getWidth() const { return width; }
private:
    double width = 1.0;
};

// Real-world scenario: a rendering engine receives mixed shapes
// and needs to apply circle-specific optimisations
void applyCircleOptimisation(const Shape* shape) {
    // dynamic_cast returns nullptr if shape is NOT a Circle — safe to check
    const Circle* circle = dynamic_cast<const Circle*>(shape);

    if (circle != nullptr) {
        // We're inside this block ONLY if the cast succeeded
        std::cout << "Optimising circle with radius: " << circle->getRadius() << "\n";
    } else {
        // Shape is something else — handle gracefully, no crash, no UB
        std::cout << "Shape is not a circle, skipping circle optimisation\n";
    }
}

int main() {
    // Simulating a mixed container — common in game engines, UI frameworks, etc.
    std::vector<std::unique_ptr<Shape>> shapeQueue;

    auto c = std::make_unique<Circle>();
    c->setRadius(5.0);
    shapeQueue.push_back(std::move(c));

    auto r = std::make_unique<Rectangle>();
    r->setWidth(10.0);
    shapeQueue.push_back(std::move(r));

    // Process each shape — dynamic_cast handles type checking safely
    for (const auto& shape : shapeQueue) {
        shape->draw();
        applyCircleOptimisation(shape.get());
    }

    // --- Reference cast: throws std::bad_cast on failure instead of returning null ---
    Circle concreteCircle;
    Shape& shapeRef = concreteCircle;
    try {
        Circle& circleRef = dynamic_cast<Circle&>(shapeRef); // succeeds
        std::cout << "Reference cast succeeded\n";
        (void)circleRef;
    } catch (const std::bad_cast& e) {
        std::cout << "Cast failed: " << e.what() << "\n";
    }

    return 0;
}

#include <iostream>
#include <cstdint>
#include <cstring>

// --- reinterpret_cast: inspecting raw memory of a float ---
// Real use case: serialisation, network protocols, hardware register inspection
void inspectFloatBits(float networkPayloadValue) {
    // Reinterpret the float's memory address as a pointer to uint32_t
    // This lets us see the IEEE 754 bit pattern without any conversion
    const uint32_t* bitPattern = reinterpret_cast<const uint32_t*>(&networkPayloadValue);
    std::cout << "Float value: " << networkPayloadValue << "\n";
    std::cout << "Raw bit pattern (hex): 0x" << std::hex << *bitPattern << std::dec << "\n";
    // Note: this is implementation-defined but works on virtually all modern platforms
}

// --- const_cast: bridging to a legacy C API ---
// Imagine this is a third-party C library function we cannot modify.
// It doesn't actually modify the string, but its signature predates const-correctness.
void legacyCPrintFunction(char* message) {
    std::cout << "Legacy API says: " << message << "\n";
}

void callLegacyAPIWithConstString(const char* readOnlyMessage) {
    // const_cast is justified ONLY because we know legacyCPrintFunction
    // does not write to the buffer. If it did, this would be undefined behaviour.
    char* mutableView = const_cast<char*>(readOnlyMessage);
    legacyCPrintFunction(mutableView);
}

int main() {
    // reinterpret_cast demo
    float sensorReading = 3.14f;
    inspectFloatBits(sensorReading);

    std::cout << "\n";

    // const_cast demo
    const char* statusMessage = "System operational";
    callLegacyAPIWithConstString(statusMessage);

    // --- What NOT to do with const_cast ---
    // const int originalLimit = 100;
    // int* hack = const_cast<int*>(&originalLimit);
    // *hack = 200; // UNDEFINED BEHAVIOUR — originalLimit was declared const
    // The compiler may optimise assuming it stays 100 forever.
    // Don't do this. Ever.

    return 0;
}