Static Casting

In C++, static casting is a way to explicitly convert one data type to another. It is a compile-time cast that can be used when there is a known relationship between the source and target types. Static casting allows conversions between related types, such as widening or narrowing numeric types, upcasting in class hierarchies, or converting pointers and references.

The syntax for static casting in C++ is as follows:

target_type variable = static_cast<target_type>(expression);

Here’s an example to demonstrate static casting in C++:

#include <iostream>

int main() {
    int myInt = 10;
    double myDouble = static_cast<double>(myInt);

    std::cout << "myInt: " << myInt << std::endl;
    std::cout << "myDouble: " << myDouble << std::endl;

    return 0;
}

In this example, we have an integer variable myInt with a value of 10. We use static casting to convert it to a double and assign the result to myDouble. The static_cast is used to explicitly specify the conversion. The resulting value of myDouble will be 10.0. The output of this program will be:

myInt: 10
myDouble: 10

In this case, the static_cast converts the integer to a double by performing a widening conversion.

It’s important to note that static casting should only be used when there is a well-defined relationship between the types and you are confident about the correctness of the conversion. If there is no known relationship between the types, or if there is a risk of data loss or undefined behavior, other forms of casting (such as dynamic_cast or reinterpret_cast) might be more appropriate.