When does Endianness become a factor?

Question

Endianness from what I understand, is when the bytes that compose a multibyte word differ in their order, at least in the most typical case. So that an 16-bit integer may be stored as either 0xHHLL or 0xLLHH.

Assuming I don't have that wrong, what I would like to know is when does Endianness become a major factor when sending information between two computers where the Endian may or may not be different.

• If I transmit a short integer of 1, in the form of a char array and with no correction, is it received and interpretted as 256?

• If I decompose and recompose the short integer using the following code, will endianness no longer be a factor?

  // Sender:
  for(n=0, n < sizeof(uint16)*8; ++n) {
      stl_bitset[n] = (value >> n) & 1;
  };
  
  // Receiver:
  for(n=0, n < sizeof(uint16)*8; ++n) {
      value |= uint16(stl_bitset[n] & 1) << n;
  };
  

• Is there a standard way of compensating for endianness?

Thanks in advance!

Answer 1

Both endianesses have an advantage that I know of:

1. Big-endian is conceptually easier to understand because it's similar to our positional numeral system: most significant to least significant.
2. Little-endian is convenient when reusing a memory reference for multiple memory sizes. Simply put, if you have a pointer to a little-endian unsigned int* but you know the value stored there is < 256, you can cast your pointer to unsigned char*.

Answer 2

1. No, though you do have the right general idea. What you're missing is the fact that even though it's normally a serial connection, a network connection (at least most network connections) still guarantees correct endianness at the octet (byte) level -- i.e., if you send a byte with a value of 0x12 on a little endian machine, it'll still be received as 0x12 on a big endian machine.

   Looking at a short, if you look at the number in hexadecimal,it'l probably help. It starts out as 0x0001. You break it into two bytes: 0x00 0x01. Upon receipt, that'll be read as 0x0100, which turns out to be 256.

2. Since the network deals with endianess at the octet level, you normally only have to compensate for the order of bytes, not bits within bytes.

3. Probably the simplest method is to use htons/htonl when sending, and ntohs/ntohl when receiving. When/if that's not sufficient, there are many alternatives such as XDR, ASN.1, CORBA IIOP, Google protocol buffers, etc.