What is static_cast in C++: Simple Explanation and Usage

static_cast in C++ is a way to convert one type to another at compile time safely when the conversion is well-defined. It is used for conversions like numeric types, pointers within an inheritance hierarchy, or explicit type changes without runtime checks.

How It Works

Imagine you have a box labeled "Fruit" and inside it is an "Apple." You know the apple is a fruit, so you can treat it as a fruit without checking every time. static_cast works similarly by telling the compiler to treat a value as a different type when it is safe and makes sense.

It performs conversions at compile time, meaning the program checks and changes the type before running. This is faster than checking during the program's execution. However, it trusts you to use it correctly; if you convert types that don't match well, the program might behave unexpectedly.

Unlike some other casts, static_cast does not do runtime checks, so it is safer than a plain C-style cast but less safe than dynamic_cast for polymorphic types.

Example

This example shows converting a floating-point number to an integer using static_cast. It safely changes the type and drops the decimal part.

cpp

#include <iostream>

int main() {
    double pi = 3.14159;
    int intPi = static_cast<int>(pi);
    std::cout << "Original double: " << pi << "\n";
    std::cout << "After static_cast to int: " << intPi << "\n";
    return 0;
}

Output

Original double: 3.14159
After static_cast to int: 3

When to Use

Use static_cast when you need to convert types explicitly and you are sure the conversion is safe and meaningful. Common cases include:

• Converting numeric types, like double to int.
• Converting pointers or references up and down an inheritance chain when you know the actual type.
• Converting enum values to integers or vice versa.

It is useful in performance-sensitive code because it avoids runtime overhead. However, avoid using it when the conversion might be unsafe or unclear; in those cases, prefer safer casts like dynamic_cast or avoid casting altogether.

Key Points

• static_cast performs compile-time type conversions.
• It is safer than C-style casts but does not check types at runtime.
• Use it for numeric conversions, pointer conversions within inheritance, and enum conversions.
• It should be used only when you are confident the conversion is valid.
• It does not work for converting unrelated pointer types or for polymorphic downcasting safely.

Key Takeaways

static_cast safely converts types at compile time without runtime checks.

Use it for numeric conversions and pointer casts within class hierarchies when safe.

Avoid static_cast for unsafe or unrelated type conversions.

It is more explicit and safer than C-style casts but less safe than dynamic_cast for polymorphism.

Always ensure the conversion makes logical sense to prevent undefined behavior.