Swapping endians when using reinterpret cast

Question

When sending data via the network converting byte data can be achieved via several ways:

12345  --> {0 0 48 57}

typedef unsigned char byte;

//1. Bit shift
int32_t shiftedInteger =  (int32_t) (inBytes[0] << 24 | inBytes[1] << 16  | 
inBytes[2] << 8 | inBytes[3]);

//2. Reinterpret cast
int32_t reinterpretedInteger = *reinterpret_cast<int32_t*>(&inBytes);

//3. Using unions
union{
    byte b[4];
    int32_t i;
}unionCast;

memcpy(unionCast.b,inBytes,4);
int_32t unionCasted = unctionCast.i;

Which is the preferable way of converting the data (use on an arduino like microporcessor)?

The union and reinterpretCast method face issues of big vs small endians but will come in handy once working with floating point numbers as simple bitshifts will not be enough to convert the data back. How can I swap endians when using reinterpret_cast?

`*reinterpret_cast(*inBytes);` is supposed to be `*reinterpret_cast(&inBytes);` ? — 463035818_is_not_an_ai, Jan 12 '18 at 12:46
@tobi303 Yes sorry. I tried to shorten my code thats where the & got lost. inBytes is an unsinged char array. — Kilian, Jan 12 '18 at 12:51
Use `std::memcpy` (unless the compiler doesn't optimize it away) and the system provided function (e.g. `ntohl`) to ensure correct endianess. — Passer By, Jan 12 '18 at 13:08
@PasserBy : this. I really, really, *really* wish more programmers did that. — Daniel Kamil Kozar, Jan 13 '18 at 14:18

Yakk - Adam Nevraumont · Accepted Answer · 2018-01-13T13:54:51.940

Your use of reinterpret and accessing inactive members of union both violate the standard. The rules saying so are known as strict aliasing.

So of your options, shifting is the only standard compliant one.

An additional option -- memcpy directly into the target type -- is also standard compliant.

You can do in place legally by memcpy to a stack array, placement new bew tyoe, then memcpy back. The optimizer will eliminate the memcpys!

You could even do this:

template<class T> 
struct raw_bytes:
  std::array<char, sizeof(T)>
{
  static_assert(std::is_pod<T>::value, "pod only");
  static raw_bytes to_raw( T in ){
    raw_bytes r;
    std::memcpy( r.data(), std::addressof(in), sizeof(T) );
    return r;
  }
  // this object no longer valid after convert, but returned reference is until this object destroyed
  T& convert(){
    char tmp[sizeof(T)];
    memcpy(tmp, data(), sizeof(T));
    T* r= ::new( (void*)data() ) T;
    memcpy(r, tmp, sizeof(T));
    return *r;
  }
};

that may or may not be worth it.

You can stick a raw_bytes in a struct and blit bytes into it. Then you can convert() those bytes in-place to T. The returned reference is the only way to legally access those bytes; methods of raw_bytes are no longer legal under a strict reading of the standard.

score 0 · Answer 2 · answered Jan 12 '18 at 13:09

0

You can't. Reinterprert cast only changes the type the compiler uses, it doesn't touch the data.

As suggested in How do I convert between big-endian and little-endian values in C++? Use

int32_t __builtin_bswap32 (int32_t x)

answered Jan 12 '18 at 13:09

Sorin

11,863
22
26

Swapping endians when using reinterpret cast

2 Answers2