When to Use reinterpret_cast vs static_cast in C++

By the end of this page, you will understand the difference between static_cast and reinterpret_cast in C++, especially for pointer conversions. You will also learn the correct cast to use when converting between void* and a class pointer in C/C++ interoperability code, and why reinterpret_cast is usually reserved for lower-level, riskier conversions.

In C++, different cast operators communicate different intentions and levels of safety.

static_cast is for well-defined conversions that the language understands. These include things like:

• numeric conversions such as int to double
• converting a derived class pointer to a base class pointer
• converting void* back to the original object pointer type
• calling explicit constructors or conversion operators

reinterpret_cast is for low-level bit-pattern reinterpretation. It tells the compiler: “treat these bits as if they were another type.” It does not usually perform a meaningful semantic conversion. Instead, it reinterprets the value at a lower level.

That is why reinterpret_cast is commonly associated with:

• pointer type punning
• converting pointers to integers and back
• interacting with low-level APIs, memory-mapped hardware, or serialization hacks

For your specific case, converting between void* and MyClass* is a standard, well-defined pointer conversion in C++. That means static_cast is the correct choice.

Example:

void* p = static_cast<*>(obj);
MyClass* obj2 = <MyClass*>(p);

Think of C++ casts like different kinds of permission slips.

• static_cast is like changing a label in a way the system understands. For example, moving a package from a box labeled “generic object” (void*) back into a box labeled “MyClass*`. The object is still the same object.
• reinterpret_cast is like telling someone to treat a package of screws as if it were a package of batteries just because the box is the same size. Sometimes low-level code does this on purpose, but it is risky and easy to misuse.

For void* and class pointers, you are not changing what the object is. You are just temporarily storing it in a generic container. That is exactly the kind of job static_cast is meant for.

The key syntax is:

static_cast<T>(expression)
reinterpret_cast<T>(expression)

Correct use for void* and class pointers

class MyClass {
public:
    void hello() {}
};

void* store_object(MyClass* obj) {
    return static_cast<void*>(obj);
}

MyClass* load_object(void* ptr) {
    return static_cast<MyClass*>(ptr);
}

Why this is correct

• MyClass* to void* is a standard pointer conversion.
• void* back to MyClass* is also supported when the void* originally came from that object pointer.
• static_cast expresses that this is a normal, language-supported conversion.

Consider this example:

class MyClass {
public:
    void hello() {}
};

int main() {
    MyClass obj;

    void* raw = static_cast<void*>(&obj);
    MyClass* typed = static_cast<MyClass*>(raw);

    typed->hello();
}

Step by step:

1. MyClass obj;

   • A MyClass object is created on the stack.

2. void* raw = static_cast<void*>(&obj);

   • &obj is a MyClass*.
   • It is converted to void*.
   • The address does not change; only the type used to describe it becomes generic.

3. MyClass* typed = static_cast<MyClass*>(raw);

   • The generic pointer is converted back to MyClass*.

This concept appears often in practical C++ programming.

1. C and C++ interoperability

C APIs cannot directly store C++ class types, so they often use opaque handles:

extern "C" void* widget_create();
extern "C" void widget_destroy(void* handle);

Internally, the handle is really a C++ object pointer.

2. Generic callback user data

Many C libraries let you pass a void* context pointer:

void register_callback(void (*fn)(void*), void* user_data);

C++ code stores an object pointer in user_data and later converts it back.

3. Plugin systems and native bindings

Frameworks that bridge languages or modules often pass around untyped handles and recover typed pointers internally.

4. Resource wrappers

A graphics, audio, or database library may expose opaque handles in public C APIs while managing rich C++ objects under the hood.

In real projects, developers usually avoid exposing C++ classes directly across a C boundary. Instead, they use an opaque handle pattern.

Common pattern: opaque handle API

class Connection {
public:
    bool open() { return true; }
};

extern "C" void* connection_create() {
    return static_cast<void*>(new Connection());
}

extern "C" int connection_open(void* handle) {
    if (!handle) {
        return 0;
    }

    Connection* conn = static_cast<Connection*>(handle);
    return conn->open() ? 1 : 0;
}

extern "C" void connection_destroy(void* handle) {
    if (!handle) {
        ;
    }

    Connection* conn = <Connection*>(handle);
     conn;
}

1. Using reinterpret_cast when static_cast is enough

Broken style:

MyClass* obj = reinterpret_cast<MyClass*>(ptr);

Better:

MyClass* obj = static_cast<MyClass*>(ptr);

Why: void* to object pointer is a standard conversion, so static_cast is clearer and safer in intent.

2. Casting a void* to the wrong type

int x = 10;
void* ptr = &x;
MyClass* obj = static_cast<MyClass*>(ptr); // compiles
obj->hello(); // undefined behavior

Avoid this by making sure the void* really came from the same original type.

3. Assuming reinterpret_cast performs value conversion

Broken assumption:

 x = ;
* f = <*>(&x);

// Generic syntax
static_cast<T>(expr)
reinterpret_cast<T>(expr)

Use static_cast for

• numeric conversions
• void* to original object pointer type
• object pointer to void*
• base/derived conversions that are statically valid
• explicit constructor or conversion operations

void* p = static_cast<void*>(obj);
MyClass* obj2 = static_cast<MyClass*>(p);

Use reinterpret_cast for

• low-level pointer reinterpretation
• pointer-to-integer or integer-to-pointer conversions
• rare systems programming cases

std::uintptr_t raw = reinterpret_cast<std::uintptr_t>(ptr);

Rules of thumb

• Prefer the least powerful cast that works.
• If static_cast can do it, use static_cast.
• does not mean “convert safely.” It means “reinterpret at a low level.”

Should I use static_cast or reinterpret_cast for void* to class pointer in C++?

Use static_cast. Converting between void* and an object pointer type is a standard, well-defined conversion.

Why does reinterpret_cast also seem to work for void* conversions?

Because it is very permissive for pointer conversions. But that does not make it the best tool. static_cast better expresses the actual language-supported conversion.

Is converting a class pointer to void* safe?

Yes. Converting an object pointer to void* and back to the same original type is a normal and common pattern.

Can static_cast from void* detect the wrong type at runtime?

No. It only performs the conversion. You must ensure that the void* really points to the expected object type.

When should I really use reinterpret_cast in C++?

Use it for low-level operations where you intentionally need to reinterpret bits or raw addresses, such as some systems programming tasks.

• void* in C and C++ — related because it is the generic pointer type used in interop APIs.
• dynamic_cast — related because it handles runtime-checked casts in inheritance hierarchies.
• C++ explicit cast operators — related because static_cast, reinterpret_cast, const_cast, and dynamic_cast each have different purposes.
• Undefined behavior — related because using the wrong pointer type after a cast can break program correctness.
• Opaque pointer pattern — related because C APIs often hide implementation details using void* handles.
• Type safety — related because choosing the right cast preserves clearer and safer intent.
• C and C++ interoperability — related because void* conversions are common at language boundaries.