C++ Casts Explained: C-Style Cast vs static_cast vs dynamic_cast

By the end of this page, you will understand what type casting means in C++, why C-style casts are usually discouraged, how static_cast performs compile-time checked conversions, and how dynamic_cast safely checks polymorphic types at runtime. You will also learn when each cast is appropriate and how to avoid common casting mistakes.

In C++, a cast converts a value or pointer from one type to another. This is sometimes necessary, but it can also be dangerous if the conversion is not valid.

The three forms in this question are not equivalent:

• C-style cast: (MyClass*)ptr
• static_cast: static_cast<MyClass*>(ptr)
• dynamic_cast: dynamic_cast<MyClass*>(ptr)

Why this matters

Types are one of the main ways C++ prevents bugs. A cast tells the compiler: "treat this value as another type." If that statement is wrong, your program may behave incorrectly or even crash.

C++ provides named casts because they make your intent clearer and separate safe conversions from dangerous conversions.

1. C-style cast

MyClass* m = (MyClass*)ptr;

This is the old C syntax. In C++, it is generally discouraged because it is too permissive.

A C-style cast may perform several different kinds of conversions behind the scenes, including ones similar to:

• static_cast
• const_cast
• reinterpret_cast

That means it can hide unsafe operations in a short, unclear syntax.

Think of casting like entering a building with different access methods.

• A C-style cast is like using a master key that opens many doors, even doors you should not open. It is powerful, but risky.
• A static_cast is like using the correct badge for a door that the building plan already says you may access. The check happens from the plan, not in real time.
• A dynamic_cast is like a security guard checking your identity at the door right now. If you are not the right person, access is denied.

Another way to think about it:

• static_cast says: "I know what this is."
• dynamic_cast says: "Please verify what this really is."
• C-style cast says: "Just do something that makes this compile."

Core syntax

// C-style cast
TargetType value = (TargetType)expression;

// static_cast
TargetType value = static_cast<TargetType>(expression);

// dynamic_cast
TargetType value = dynamic_cast<TargetType>(expression);

Example: static_cast with numbers

double price = 19.99;
int whole = static_cast<int>(price);

whole becomes 19. This is a normal compile-time conversion.

Example: upcasting with inheritance

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

class Dog : public Animal {
};

Dog dog;
Animal* animalPtr = static_cast<Animal*>(&dog);

This is safe because every Dog is an Animal.

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* a = static_cast<Derived*>(ptr);
    if (a) {
        a->hello();
    }

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

    delete ptr;
}

What happens step by step

1. Base* ptr = new Derived();

   • A Derived object is created.
   • It is stored in a Base* pointer.

Where static_cast is commonly used

Numeric conversions

double ratio = 3.8;
int count = static_cast<int>(ratio);

Useful when parsing values, formatting output, or converting between numeric types.

Converting void* from low-level APIs

void* raw = get_buffer();
char* bytes = static_cast<char*>(raw);

This appears in older APIs, callback systems, and C libraries.

Upcasting in class hierarchies

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

This happens frequently when storing derived objects behind base-class interfaces.

Where dynamic_cast is commonly used

Working with plugin or framework object hierarchies

A framework may give you a Base*, and you may need to check whether it is actually a more specific subtype.

Processing mixed collections of polymorphic objects

In real C++ projects, developers usually prefer clear and narrow casts.

Common patterns

1. Prefer no cast if design can avoid it

Good class design often removes the need for downcasting entirely.

For example, virtual functions are often better than checking types manually:

class Animal {
public:
    virtual ~Animal() = default;
    virtual void speak() = 0;
};

class Dog : public Animal {
public:
    void speak() override {
        std::cout << "Woof\n";
    }
};

Instead of casting to Dog, call speak() through the base interface.

2. Use static_cast for explicit, expected conversions

Developers often use static_cast when they want a visible conversion in code review:

1. Using static_cast for unsafe downcasting

Broken example:

Animal* animal = new Cat();
Dog* dog = static_cast<Dog*>(animal);
dog->bark(); // Undefined behavior

Why it is wrong:

• static_cast does not verify that animal really points to a Dog.

How to avoid it:

Dog* dog = dynamic_cast<Dog*>(animal);
if (dog) {
    dog->bark();
}

2. Forgetting that dynamic_cast needs a polymorphic base class

Broken example:

class Base {};
class Derived : public Base {};

Base* ptr = new Derived();
Derived* d = dynamic_cast<Derived*>(ptr); // Error

Why it is wrong:

static_cast vs dynamic_cast

Quick rules

• Prefer named C++ casts over C-style casts.
• Use static_cast for explicit, expected conversions.
• Use dynamic_cast for safe runtime-checked downcasting.
• dynamic_cast works with polymorphic base classes.
• Failed dynamic_cast on pointers returns nullptr.
• Failed dynamic_cast on references throws std::bad_cast.

Syntax

T value = static_cast<T>(expr);
T value = dynamic_cast<T>(expr);
T value = (T)expr; // C-style cast, usually avoid in C++

Safe examples

int x = static_cast<int>(3.14);
Base* b = static_cast<Base*>(&derivedObj);

if (Derived* d = dynamic_cast<Derived*>(basePtr)) {
    d->run();
}

Warning signs

What is the difference between static_cast and dynamic_cast in C++?

static_cast performs compile-time conversions without checking the real runtime object type. dynamic_cast checks the actual runtime type and is safer for downcasting in inheritance hierarchies.

Is a C-style cast the same as static_cast?

No. A C-style cast can behave like static_cast, but it can also perform more dangerous kinds of conversions. That is why it is less safe and less explicit.

When should I use dynamic_cast?

Use it when you have a base-class pointer or reference and need to safely determine whether the object is really a specific derived type at runtime.

Why does dynamic_cast require a virtual function?

It needs runtime type information, which is available for polymorphic classes. A class becomes polymorphic when it has at least one virtual function.

Does dynamic_cast have a performance cost?

Yes, usually more than static_cast, because it performs a runtime check. In most code, correctness matters more than this small cost unless profiling shows otherwise.

Should I avoid all casts in C++?

• const_cast — Used to add or remove const qualification, another named C++ cast.
• reinterpret_cast — Used for low-level bit-pattern reinterpretation, much more dangerous than static_cast.
• Polymorphism — dynamic_cast relies on polymorphic class hierarchies.
• Inheritance — Casting between base and derived classes only makes sense in inheritance relationships.
• Virtual functions — A base class usually needs a virtual function for dynamic_cast to work.
• Undefined behavior — Unsafe casts can produce invalid behavior that compiles but is not reliable.
• Upcasting and downcasting — These are the common directions of conversion in class hierarchies.
• Type safety — Named casts exist to make conversions more explicit and safer.