Posted By: HeretoLearn
I am little confused with the applicability of
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_casts are applicable in two scenarios:
- convert integer types to pointer types and vice versa
- 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
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?
The C++ standard guarantees the following:
static_casting a pointer to and from
void* preserves the address. That is, in the following,
c all point to the same address:
int* a = new int(); void* b = static_cast<void*>(a); int* c = static_cast<int*>(b);
reinterpret_cast only guarantees that if you cast a pointer to a different type, and then
reinterpret_cast it back to the original type, you get the original value. So in the following:
int* a = new int(); void* b = reinterpret_cast<void*>(a); int* c = reinterpret_cast<int*>(b);
c contain the same value, but the value of
b is unspecified. (in practice it will typically contain the same address as
c, but that’s not specified in the standard, and it may not be true on machines with more complex memory systems.)
For casting to and from
static_cast should be preferred.