Static_cast in C

Static_cast is a type of casting operator in C used for explicit type conversion.

It can perform conversions between related types, such as converting pointers to base classes to pointers to derived classes and vice versa.

Syntax of static_cast:

 static_cast(expression) 

Dynamic_cast:

Dynamic_cast is another type of casting operator in C that is primarily used for performing downcasting in polymorphic class hierarchies.

It ensures type safety by performing runtime type checking.

---

Const_cast:

Const_cast is used to add or remove the const qualifier from a variable.

It is often used to cast away the constness of a variable when necessary, but it should be used with caution to avoid undefined behavior.

---

Reinterpret_cast:

Reinterpret_cast is the most dangerous type of casting operator in C, as it can reinterpret the bit pattern of an object into another type.

It should be used sparingly and only when absolutely necessary, as it can lead to undefined behavior if misused.

Different Scenarios and Behavior of static_cast

Implicit Conversions:

Static_cast can be used for implicit conversions between related types, such as converting integers to floating-point numbers or vice versa.

It ensures type safety during the conversion process.

---

Pointer Conversions:

Static_cast can be used to perform pointer conversions between related types, such as converting pointers to base classes to pointers to derived classes and vice versa.

It allows for safe and explicit type casting.

---

Enum Conversions:

Static_cast can be used to convert enum types to integral types and vice versa.

It ensures type safety by performing compile-time type checking.

---

Arithmetic Conversions:

Static_cast can be used to perform arithmetic conversions between different numeric types, such as converting between integers and floating-point numbers.

It ensures type safety by performing compile-time type checking.

---

User-defined Conversions:

Static_cast can be used to perform user-defined type conversions by defining conversion functions or conversion operators.

It allows for safe and explicit conversion between user-defined types.

---

Programs for the usage of static_cast, dynamic_cast, const_cast, and reinterpret_cast:

// program for static_cast in C
#include<iostream> 

class Base {
public:
    virtual void print() { std::cout << "Base" << std::endl; }
};

class Derived : public Base {
public:
    void print() override { std::cout << "Derived" << std::endl; }
};

int main() {
    // static_cast example
    double x = 3.14;
    int y = static_cast<int>(x);
    std::cout << "Static_cast: " << y << std::endl;

    // dynamic_cast example
    Base* basePtr = new Derived();
    Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);
    if (derivedPtr) {
        derivedPtr->print();
    }

    // const_cast example
    const int z = 10;
    int& zRef = const_cast<int&>(z);
    zRef = 20;
    std::cout << "Const_cast: " << z << std::endl;

    // reinterpret_cast example
    int* ptr = new int(42);
    long ptrValue = reinterpret_cast<long>(ptr);
    std::cout << "Reinterpret_cast: " << ptrValue << std::endl;

    return 0;
}	

Output:

Static_cast: 3
Derived
Const_cast: 10
Reinterpret_cast: 16958176

These programs demonstrate various scenarios where static_cast, dynamic_cast, const_cast, and reinterpret_cast are used for type conversions and their respective behaviors in different contexts.