When to Use static_cast, dynamic_cast, const_cast, and reinterpret_cast in C++

By the end of this page, you will understand what each C++ cast is designed for, when it is appropriate to use it, and which casts are risky or should usually be avoided. You will also learn how to choose the safest cast for common programming situations, especially when converting between numeric types, working with inheritance, removing const, or dealing with low-level memory operations.

C++ provides several different cast operators because not all type conversions mean the same thing.

In older C-style code, a cast like (type)value could do many different things at once. That makes code shorter, but also less clear and less safe. C++ introduced named casts so the programmer's intent is explicit.

Here is the big idea:

• static_cast is for normal, compile-time conversions.
• dynamic_cast is for safe casting in inheritance hierarchies at runtime.
• const_cast is for adding or removing const or volatile qualifiers.
• reinterpret_cast is for low-level bit-pattern reinterpretation.
• C-style and function-style casts are less explicit and may perform one of several kinds of conversions.

Why this matters:

• It makes code easier to read.
• It makes unsafe operations easier to spot.
• It helps the compiler catch mistakes.
• It communicates whether a conversion is routine, runtime-checked, qualifier-related, or low-level.

A useful rule of thumb is:

1. Avoid casting if you can. Prefer designing code so conversion is unnecessary.
2. If you must cast, use the most specific named cast.
3. Avoid C-style casts in modern C++ because they can hide dangerous conversions.

Think of C++ casts as different kinds of permission slips:

• static_cast = standard office form. Normal, expected conversions.
• dynamic_cast = security checkpoint. It checks identity before allowing entry.
• const_cast = removing a “do not modify” sticker. Dangerous if the object was truly meant to stay unchanged.
• reinterpret_cast = labeling one box as if it were a completely different box. Sometimes necessary at low level, but very risky.
• C-style cast = a mystery shortcut. It might do several things, and readers cannot easily tell which one.

Another way to remember it:

• static_cast: “Convert this in a normal way.”
• dynamic_cast: “Check what this object really is at runtime.”
• const_cast: “Change constness only.”
• reinterpret_cast: “Treat these bits/address as another type.”

The more specific the cast, the clearer your code is.

Core syntax

static_cast<NewType>(value)
dynamic_cast<NewType>(value)
const_cast<NewType>(value)
reinterpret_cast<NewType>(value)

Older forms:

(NewType)value
NewType(value)

static_cast example

#include <iostream>

int main() {
    double temperature = 23.7;
    int roundedDown = static_cast<int>(temperature);

    std::cout << roundedDown << '\n';
}

static_cast<int>(temperature) converts 23.7 to 23. This is a normal numeric conversion.

dynamic_cast example

  {
:
     ~() = ;
};

  :  Shape {
:
    {
        std::cout << ;
    }
};

{
    Shape* shape =  ();

    Circle* circle = <Circle*>(shape);
     (circle) {
        circle->();
    }

     shape;
}

Consider this example:

#include <iostream>

class Base {
public:
    virtual ~Base() = default;
};

class Derived : public Base {
public:
    void hello() {
        std::cout << "Hello from Derived\n";
    }
};

int main() {
    Base* ptr = new Derived();

    Derived* d1 = static_cast<Derived*>(ptr);
    d1->hello();

    Derived* d2 = dynamic_cast<Derived*>(ptr);
    if (d2) {
        d2->hello();
    }

    delete ptr;
}

What happens step by step

1. Base* ptr = new Derived();

   • A Derived object is created.
   • It is stored in a pointer of type Base*.
   • This is an , and it is safe.

Numeric and data conversions

static_cast is commonly used when:

• converting double to int
• converting enum values to integers
• converting sizes between numeric types intentionally

double total = 42.8;
int whole = static_cast<int>(total);

Object-oriented code with inheritance

dynamic_cast is useful when working with plugin systems, UI widgets, AST nodes, or game objects where a base pointer may actually refer to different derived types.

Widget* widget = getSelectedWidget();
Button* button = dynamic_cast<Button*>(widget);
if (button) {
    button->click();
}

Interfacing with legacy APIs

const_cast may be needed when an old library takes a non-const pointer even though it does not modify the data.

legacy_api(const_cast<char*>(name.c_str()));

In real C++ codebases, casts often appear as part of defensive patterns.

1. Prefer no cast when possible

Developers often redesign APIs so callers do not need casts.

Instead of this:

void process(Base* obj);

You may see virtual functions used so the correct behavior is chosen automatically.

2. static_cast for explicit intent

When narrowing or converting intentionally, developers use static_cast to show that data loss or transformation is expected.

int size = static_cast<int>(items.size());

This is common when an API expects a specific numeric type.

3. dynamic_cast for safe downcasting at boundaries

In large codebases, dynamic_cast is often used at framework boundaries where a generic interface returns a base pointer, and code must verify the exact subtype.

if (auto* fileLogger = dynamic_cast<FileLogger*>(logger)) {
    fileLogger->();
}

1. Using static_cast for unsafe downcasting

Broken example:

class Base {
public:
    virtual ~Base() = default;
};

class Derived : public Base {
public:
    void hello() {}
};

Base base;
Base* ptr = &base;
Derived* d = static_cast<Derived*>(ptr); // dangerous

This compiles, but ptr does not actually point to a Derived. Using d as a Derived* is undefined behavior.

Use dynamic_cast when you need runtime checking.

2. Removing const and then modifying truly const data

Broken example:

const int value = 10;
int* p = <*>(&value);
*p = ; 

Cast comparison table

Quick rules

• Best rule: avoid casting unless necessary.
• Prefer named casts over C-style casts.
• Use the most specific cast for your intent.

Which cast should I use?

• Normal conversion? -> static_cast
• Need runtime type check in inheritance? -> dynamic_cast
• Only changing const or volatile? -> const_cast
• Low-level bit/address reinterpretation? -> reinterpret_cast
• Old (type)value cast? -> usually replace with a named cast

Syntax

static_cast<T>(value)
dynamic_cast<T>(value)
const_cast<T>(value)
reinterpret_cast<T>(value)

Safety notes

• static_cast

  • good for explicit numeric conversions
  • no runtime safety for downcasts

• dynamic_cast

What is the safest cast in C++?

There is no single safest cast for every case, but static_cast is the usual safe choice for normal explicit conversions, and dynamic_cast is safest for uncertain downcasts in polymorphic class hierarchies.

Why are C-style casts discouraged in C++?

Because they are ambiguous. A C-style cast can perform several different kinds of conversions, making code harder to read and easier to misuse.

When should I use dynamic_cast instead of static_cast?

Use dynamic_cast when converting from a base type to a derived type and the real object type may vary at runtime.

Can const_cast remove const safely?

It can remove the qualifier syntactically, but modifying an object that was originally declared const is undefined behavior.

Is reinterpret_cast portable?

Often not fully. It is closely tied to platform details, memory layout, and representation rules, so it should be used carefully and sparingly.

Does dynamic_cast require virtual functions?

Yes, the base class must be polymorphic, which usually means it has at least one virtual function such as a virtual destructor.

• Inheritance — dynamic_cast and many pointer casts make sense only in class hierarchies.
• Polymorphism — runtime type checking depends on polymorphic behavior.
• Virtual functions — dynamic_cast requires a polymorphic base, usually created with virtual functions.
• Const correctness — const_cast is directly related to how const is used in APIs.
• Type conversion — static_cast is part of the broader idea of explicit and implicit conversions.
• Undefined behavior — incorrect casts can compile but still break program correctness.
• Pointers and references — many casts apply to pointers and references, especially in object-oriented code.
• RAII and object lifetime — safe pointer use and deletion matter when casting objects in class hierarchies.