reinterpret_cast vs. static_cast for writing bytes in standard-layout types?
c++, c++11, reinterpret-cast, standard-layout, visual-c++-2005
Solution
In this case (converting object pointers), `reinterpret_cast` is identical to the two nested `static_cast` via `void*`
5.2.10 Reinterpret cast [expr.reinterpret.cast]
7 An object pointer can be explicitly converted to an object pointer of a different type.72 When a prvalue v of object pointer type is converted to the object pointer type “pointer to cv T”, the result is `static_cast<cv T*>(static_cast<cv void*>(v))`. Converting a prvalue of type “pointer to T1” to the type “pointer to T2” (where T1 and T2 are object types and where the alignment requirements of T2 are no stricter than those of T1) and back to its original type yields the original pointer value.
It is better to use `reinterpret_cast` to signal your intent here.
UPDATE: as mentioned in the comments, this was apparently added in C++11, although most C++98 compilers already supported it (see also this Q&A)
Problem
I need to write to individual bytes of some integer types. Should I used `reinterpret_cast`, or should I use `static_cast` via `void*`? (a) ``` unsigned short v16; char* p = static_cast<char*>(static_cast<void*>(&v16)); p[1] = ... some char value p[0] = ... some char value ``` or (b) ``` unsigned short v16; char* p = reinterpret_cast<char*>(&v16); p[1] = ... some char value p[0] = ... some char value ``` According to static_cast and reinterpret_cast for std::aligned_storage 's answer both should be equivalent -- -- if both T1 and T2 are standard-layout types and the alignment requirements of T2 are no stricter than those of T1 I'm leaning towards `reinterpret_cast` as that is essentially what I'm doing, isn't it? Are there any other things to consider, specifically looking at Visual-C++ and VC8, the version we're currently compiling on? (x86 only atm.)