I am little confused with the applicability of <code>reinterpret_cast</code> vs <code>static_cast</code>. 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 <code>static</code>. This is the cast the C++ compiler uses internally for implicit casts also. <code>reinterpret_cast</code>s are applicable in two scenarios: <ul> <li>convert integer types to pointer types and vice versa </li> <li>convert one pointer type to another. The general idea I get is this is unportable and should be avoided. </li> </ul> 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 <code>void*</code>. What cast should be used to convert between the <code>void *</code> and the Class type? I have seen usage of both <code>static_cast</code> and <code>reinterpret_cast</code>? Though from what I have been reading it appears <code>static</code> is better as the cast can happen at compile time? Though it says to use <code>reinterpret_cast</code> to convert from one pointer type to another?

The C++ standard guarantees the following: <code>static_cast</code>ing a pointer to and from <code>void*</code> preserves the address. That is, in the following, <code>a</code>, <code>b</code> and <code>c</code> all point to the same address: <pre class="prettyprint"><code>int* a = new int(); void* b = static_cast<void*>(a); int* c = static_cast<int*>(b); </code></pre> <code>reinterpret_cast</code> only guarantees that if you cast a pointer to a different type, and then <code>reinterpret_cast</code> it back to the original type, you get the original value. So in the following: <pre class="prettyprint"><code>int* a = new int(); void* b = reinterpret_cast<void*>(a); int* c = reinterpret_cast<int*>(b); </code></pre> <code>a</code> and <code>c</code> contain the same value, but the value of <code>b</code> is unspecified. (in practice it will typically contain the same address as <code>a</code> and <code>c</code>, 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 <code>void*</code>, <code>static_cast</code> should be preferred.

When to use reinterpret

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_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 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?

What is the point of reinterpret_cast?

reinterpret_cast is a type of casting operator used in C++. It is used to convert a pointer of some data type into a pointer of another data type, even if the data types before and after conversion are different. It does not check if the pointer type and data pointed by the pointer is same or not.

What is the difference between static_cast Dynamic_cast Const_cast and reinterpret_cast?

Use static_cast as the equivalent of a C-style cast that does value conversion, or when we need to explicitly up-cast a pointer from a class to its superclass. Use const_cast to remove the const qualifier. Use reinterpret_cast to do unsafe conversions of pointer types to and from integer and other pointer types.

When should I use static_cast?

This is used for the normal/ordinary type conversion. This is also the cast responsible for implicit type coersion and can also be called explicitly. You should use it in cases like converting float to int, char to int, etc.

Is reinterpret_cast safe?

the result of a pointer-to-pointer reinterpret_cast operation can't safely be used for anything other than being cast back to the original pointer type.

The C++ standard guarantees the following:

static_casting a pointer to and from void* preserves the address. That is, in the following, a, b and 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);

a and c contain the same value, but the value of b is unspecified. (in practice it will typically contain the same address as a and 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 void*, static_cast should be preferred.

When to use reinterpret_cast?

Tags:

c++

casting

reinterpret-cast

HeretoLearn

People also ask

1 Answers

jalf

Recent Activity

Donate For Us