When to use reinterpret_cast?

Question

I am little confused with the applicability of `reinterpret_cast` vs `static_cast`. From what I have read the general rules are to use static cast when the types can be interpreted at compile time hence the word `static`. This is the cast the C++ compiler uses internally for implicit casts also. `reinterpret_cast`s are applicable in two scenarios, convert integer types to pointer types and vice versa or to convert one pointer type to another. The general idea I get is this is unportable and should be avoided. Where I am a little confused is one usage which I need, I am calling C++ from C and the C code needs to hold on to the C++ object so basically it holds a `void*`. What cast should be used to convert between the `void *` and the Class type? I have seen usage of both `static_cast` and `reinterpret_cast`? Though from what I have been reading it appears `static` is better as the cast can happen at compile time? Though it says to use `reinterpret_cast` to convert from one pointer type to another?

Answer 1

Hi!

The purpose of reinterpret_cast is to reinterpret the bits of one value as the bits of another value. Generally reinterpret_cast is much less restrictive than other C++ style casts in that it will allow you to cast most types to most other types which is both it's strength and weakness. It is similar in use to a plain C-style cast and generally static_cast should be preferred if possible because it will prevent you from accidentally trying to convert one type to an incompatible type like converting a struct type to a pointer type.

Your example of converting a void* to a Class type should use static_cast as a conversion from void* to T* is a well defined conversion by the compiler as a void* is a valid pointer to a class type. By casting it, you are just making it more specific to the compiler what the pointer is pointing to. A reinterpret_cast is unnecessary here and static_cast should be preferred.

Hope this helps!