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

User · Answer

You could use reinterprete cast to check inheritance at compile time  Look here  Using reinterpret cast to check inheritance at compile time

User · Answer

The meaning of reinterpret cast is not defined by the C   standard  Hence  in theory a reinterpret cast could crash your program  In practice compilers try to do what you expect  which is to interpret the bits of what you are passing in as if they were the type you are casting to  If you know what the compilers you are going to use do with reinterpret cast  you can use it  but to say that it is portable would be lying   For the case you describe  and pretty much any case where you might consider reinterpret cast  you can use static cast or some other alternative instead  Among other things the standard has this to say about what you can expect of static cast    5 2 9       An rvalue of type    pointer to cv void    can be explicitly converted to a pointer to object type  A value of type pointer to object converted to    pointer to cv void    and back to the original pointer type will have its original value    So for your use case  it seems fairly clear that the standardization committee intended for you to use static cast

User · Answer

First you have some data in a specific type like int here   int x   0x7fffffff     nan in binary representation   Then you want to access the same variable as an other type like float  You can decide between  float y   reinterpret cast lt float amp  gt  x      this could only be used in cpp  looks like a function with template-parameters   or  float y     float   amp  x      this could be used in c and cpp   BRIEF  it means that the same memory is used as a different type  So you could convert binary representations of floats as int type like above to floats  0x80000000 is -0 for example  the mantissa and exponent are null but the sign  the msb  is one  This also works for doubles and long doubles   OPTIMIZE  I think reinterpret cast would be optimized in many compilers  while the c-casting is made by pointerarithmetic  the value must be copied to the memory  cause pointers couldn t point to cpu- registers    NOTE  In both cases you should save the casted value in a variable before cast  This macro could help    define asvar x    decltype x    tmp      x     tmp

User · Answer

The short answer  If you don t know what reinterpret cast stands for  don t use it  If you will need it in the future  you will know   Full answer   Let s consider basic number types   When you convert for example int 12  to unsigned float  12 0f  your processor needs to invoke some calculations as both numbers has different bit representation  This is what static cast stands for   On the other hand  when you call reinterpret cast the CPU does not invoke any calculations  It just treats a set of bits in the memory like if it had another type  So when you convert int  to float  with this keyword  the new value  after pointer dereferecing  has nothing to do with the old value in mathematical meaning   Example  It is true that reinterpret cast is not portable because of one reason - byte order  endianness   But this is often surprisingly the best reason to use it  Let s imagine the example  you have to read binary 32bit number from file  and you know it is big endian  Your code has to be generic and works properly on big endian  e g  some ARM  and little endian  e g  x86  systems  So you have to check the byte order  It is well-known on compile time so you can write constexpr function  You can write a function to achieve this     constexpr   bool is little endian       std  uint16 t x 0x0001    auto p   reinterpret cast lt std  uint8 t  gt   amp x     return  p    0      Explanation  the binary representation of x in memory could be 0000 0000 0000 0001  big  or 0000 0001 0000 0000  little endian   After reinterpret-casting the byte under p pointer could be respectively 0000 0000 or 0000 0001  If you use static-casting  it will always be 0000 0001  no matter what endianness is being used   EDIT   In the first version I made example function is little endian to be constexpr  It compiles fine on the newest gcc  8 3 0  but the standard says it is illegal  The clang compiler refuses to compile it  which is correct

User · Answer

template  lt class outType  class inType gt  outType safe cast inType pointer        void  temp   static cast lt void  gt  pointer       return static cast lt outType gt  temp       I tried to conclude and wrote a simple safe cast using templates  Note that this solution doesn t guarantee to cast pointers on a functions

User · Answer

One use of reinterpret cast is if you want to apply bitwise operations to  IEEE 754  floats  One example of this was the Fast Inverse Square-Root trick   https   en wikipedia org wiki Fast inverse square root Overview of the code  It treats the binary representation of the float as an integer  shifts it right and subtracts it from a constant  thereby halving and negating the exponent  After converting back to a float  it s subjected to a Newton-Raphson iteration to make this approximation more exact    float Q rsqrt  float number         long i      float x2  y      const float threehalfs   1 5F       x2   number   0 5F      y    number      i        long      amp y                           evil floating point bit level hacking     i    0x5f3759df -   i  gt  gt  1                     what the deuce       y        float      amp i      y    y     threehalfs -   x2   y   y           1st iteration     y    y     threehalfs -   x2   y   y           2nd iteration  this can be removed      return y      This was originally written in C  so uses C casts  but the analogous C   cast is the reinterpret cast

User · Answer

Quick answer  use static cast if it compiles  otherwise resort to reinterpret cast

User · Answer

Read the FAQ  Holding C   data in C can be risky   In C    a pointer to an object can be converted to void   without any casts  But it s not true the other way round  You d need a static cast to get the original pointer back

User · Answer

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 lt void  gt  a   int  c   static cast lt int  gt  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 lt void  gt  a   int  c   reinterpret cast lt int  gt  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

User · Answer

Here is a variant of Avi Ginsburg s program which clearly illustrates the property of reinterpret cast mentioned by Chris Luengo  flodin  and cmdLP   that the compiler treats the pointed-to memory location as if it were an object of the new type   include  lt iostream gt   include  lt string gt   include  lt iomanip gt  using namespace std   class A   public      int i      class B   public A   public      virtual void f          int main         string s      B b      b i   0      A  as   static cast lt A  gt   amp b       A  ar   reinterpret cast lt A  gt   amp b       B  c   reinterpret cast lt B  gt  ar            cout  lt  lt   quot as- gt i    quot   lt  lt  hex  lt  lt  setfill  0     lt  lt  as- gt i  lt  lt   quot  n quot       cout  lt  lt   quot ar- gt i    quot   lt  lt  ar- gt i  lt  lt   quot  n quot       cout  lt  lt   quot b i      quot   lt  lt  b i  lt  lt   quot  n quot       cout  lt  lt   quot c- gt i     quot   lt  lt  c- gt i  lt  lt   quot  n quot       cout  lt  lt   quot  n quot       cout  lt  lt   quot  amp  as- gt i     quot   lt  lt   amp  as- gt i   lt  lt   quot  n quot       cout  lt  lt   quot  amp  ar- gt i     quot   lt  lt   amp  ar- gt i   lt  lt   quot  n quot       cout  lt  lt   quot  amp  b i     quot   lt  lt   amp  b i   lt  lt   quot  n quot       cout  lt  lt   quot  amp  c- gt i     quot   lt  lt   amp  c- gt i   lt  lt   quot  n quot       cout  lt  lt   quot  n quot       cout  lt  lt   quot  amp b    quot   lt  lt   amp b  lt  lt   quot  n quot       cout  lt  lt   quot as    quot   lt  lt  as  lt  lt   quot  n quot       cout  lt  lt   quot ar    quot   lt  lt  ar  lt  lt   quot  n quot       cout  lt  lt   quot c     quot   lt  lt  c   lt  lt   quot  n quot            cout  lt  lt   quot Press ENTER to exit  n quot       getline cin s      Which results in output like this  as- gt i   0 ar- gt i   50ee64 b i     0 c- gt i    0   amp  as- gt i    00EFF978  amp  ar- gt i    00EFF974  amp  b i      00EFF978  amp  c- gt i     00EFF978   amp b   00EFF974 as   00EFF978 ar   00EFF974 c    00EFF974 Press ENTER to exit   It can be seen that the B object is built in memory as B-specific data first  followed by the embedded A object   The static cast correctly returns the address of the embedded A object  and the pointer created by static cast correctly gives the value of the data field   The pointer generated by reinterpret cast treats b s memory location as if it were a plain A object  and so when the pointer tries to get the data field it returns some B-specific data as if it were the contents of this field  One use of reinterpret cast is to convert a pointer to an unsigned integer  when pointers and unsigned integers are the same size   int i  unsigned int u   reinterpret cast lt unsigned int gt   amp i

User · Answer

One case when reinterpret cast is necessary is when interfacing with opaque data types   This occurs frequently in vendor APIs over which the programmer has no control   Here s a contrived example where a vendor provides an API for storing and retrieving arbitrary global data      vendor hpp typedef struct  Opaque   VendorGlobalUserData  void VendorSetUserData VendorGlobalUserData p   VendorGlobalUserData VendorGetUserData      To use this API  the programmer must cast their data to VendorGlobalUserData and back again   static cast won t work  one must use reinterpret cast      main cpp  include  vendor hpp   include  lt iostream gt  using namespace std   struct MyUserData       MyUserData     m 42         int m      int main         MyUserData u              store global data     VendorGlobalUserData d1      d1    amp u                                              compile error     d1   static cast lt VendorGlobalUserData gt   amp u            compile error     d1   reinterpret cast lt VendorGlobalUserData gt   amp u       ok     VendorSetUserData d1               do other stuff                retrieve global data     VendorGlobalUserData d2   VendorGetUserData        MyUserData   p   0      p   d2                                               compile error     p   static cast lt MyUserData   gt  d2                     compile error     p   reinterpret cast lt MyUserData   gt  d2                ok      if  p    cout  lt  lt  p- gt m  lt  lt  endl        return 0      Below is a contrived implementation of the sample API      vendor cpp static VendorGlobalUserData g   0  void VendorSetUserData VendorGlobalUserData p    g   p    VendorGlobalUserData VendorGetUserData     return g

[c++] When to use reinterpret_cast?

Examples related to c++

Examples related to casting

Examples related to reinterpret-cast