3

I'm confused when I was reading an article about Big/Little Endian.

Code goes below:

#include <iostream>
using namespace std;

int i = 12345678;

int main()
{
    char *p = (char*)&i;  //line-1

    if(*p == 78)  //line-2
        cout << "little endian" << endl;
    if(*p == 12)
        cout << "big endian" << endl;

}

Question:

  1. In line-1, can I do the conversion using static_cast<char*>(&i)?

  2. In line-2, according to the code, if it's little-endian, then 78 is stored in the lowest byte, else 12 is stored in the lowest byte. But what I think is that, i = 12345678; will be stored in memory in binary.

    If it's little-endian, then the last byte of i's binary will be stored in the lowest byte, but what I don't understand is how can it guarantee that the last byte of i is 78?

    Just like, if i = 123;, then i's binary is 01111011, can it guarantee that in little-endian, 23 is stored in the lowest byte?

Alcott
  • 17,905
  • 32
  • 116
  • 173

4 Answers4

9

  1. I'd prefer a reinterpret_cast.

  2. Little-endian and big-endian refer to the way bytes, i.e. 8-bit quantities, are stored in memory, not two-decimal quantities. If i had the value 0x12345678, then you could check for 0x78 and 0x12 to determine endianness, since two hex digits correspond to a single byte (on all the hardware that I've programmed for).

Fred Foo
  • 355,277
  • 75
  • 744
  • 836
  • Can you expand on "check for 0x78 and 0x12 to determine endianness"? –  Sep 21 '11 at 12:09
  • if `i` is hexadecimal, then `0x12 0x34 0x56 0x78` will respectively take one byte after another? – Alcott Sep 21 '11 at 12:10
  • Not really. I was wanting you to expand on how to check. –  Sep 21 '11 at 12:11
  • 1
    @Alcott: yes, two hex digits are exactly one byte. That's because a hex digit stores one of 16 distinct values and 16² = 256 = 2^8. – Fred Foo Sep 21 '11 at 12:12
  • @CodeMonkey: the check is in the OP's code. It works if you prefix the constants with `0x` in the source code. – Fred Foo Sep 21 '11 at 12:13
4

There are two different involved concept here:

  1. Numbers are stored in binary format. 8bits represent a byte, integers can use 1,2,4 or even 8 or 1024 bytes depending on the platform they run on.
  2. Endiannes is the order bytes have in memory (less significant first - LE, or most significant first - BE)

Now, 12345678 is a decimal number whose binary (base2) representation is 101111000110000101001110. Not that easy to be checked, mainly because base2 representation doesn't group exactly into one decimal digit. (there is no integer x so that 2x gives 10). Hexadecimal number are easyer to fit: 24=16 and 28=162=256.

So the hexadecimal number 0x12345678 forms the bytes 0x12-0x34-0x56-0x78. Now it's easy to check if the first is 0x12 or 0x78.

(note: the hexadecimal representation of 12345678 is 0x00BC614E, where 0xBC is 188, 0x61 is 97 and 0x4E is 78)

Emilio Garavaglia
  • 20,229
  • 2
  • 46
  • 63
1

  1. static_cast is one new-style alternative to old-fashioned C-style casts, but it's not appropriate here; reinterpret_cast is for when you're completely changing the data type.

  2. This code simply won't work -- bytes don't hold an even number of decimal digits! The digits of a decimal number don't match up one-to-one with the bytes stored in memory. Decimal 500, for example, could be stored in two bytes as 0x01F4. The "01" stands for 256, and the "F4" is another 244, for a total of 500. You can't say that the "5" from "500" is in either of those two bytes -- there's no direct correspondence.

Ernest Friedman-Hill
  • 80,601
  • 10
  • 150
  • 186
  • don't hold an even number of decimal digits? I don't quite understand sir. – Alcott Sep 21 '11 at 12:08
  • it seems I can't use `static_cast`, because I got an error "error: invalid static_cast from type ‘int*’ to type ‘char*’". – Alcott Sep 21 '11 at 12:14
  • 2
    `static_cast` is for conversion between related types. `reinterpret_cast` is for conversion between arbitrary pointer types. – Fred Foo Sep 21 '11 at 12:16
  • @Alcott - you understand better than you think - what is the decimal value of the binary number '1111' ? How many digits is that ? – Hugh Jones Sep 21 '11 at 12:18
  • 1
    @Alcott - as the answers imply, 12345678 (base 10) is stored as 0x00BC614E. You would have to look for bytes '00' or '4E' unless you meant 0x12345678 (base 16) – StuartLC Sep 21 '11 at 12:18
  • 2
    By "doesn't hold an even number of decimal digits" I meant to say that the digits of a decimal number don't match up one-to-one with the bytes stored in memory. Decimal 500, for example, could be stored in two bytes as 0x01F4. The "01" stands for 256, and the "F4" is another 244, for a total of 500. You can't say that the "5" from "500" is in either of those two bytes -- there's no direct correspondence. – Ernest Friedman-Hill Sep 21 '11 at 12:20
0

It should be 

unsigned char* p = (unsigned char*)&i;

You cannot use static_cast. Only reinterpret_cast.

Vishal
  • 1,199
  • 1
  • 8
  • 13