I have been doing computer programming for around 8 years now and some of the topics I always brushed away included bit-level and low-level under-the-hood concepts that are often abstracted from the programmer by high level languages such as Java and C#. Over time I realized that I did not fully understand what really happens on the "metal" when it came to topics like bit manipulation. Learning C and C++ made me realize the need to understand what happens at the low level. To help me remember what I learned and hopefully clarify to other readers, I am going to share what I learned about endianness on x86-based systems, which are [Little Endian](https://www.cs.umd.edu/class/sum2003/cmsc311/Notes/Data/endian.html). Jumping straight into the code, I have written a very simple to understand program that will show how bits and bytes are stored in memory on an x86 system. It is very important to remember that endianness is about *bytes* not *bits* - very important point to remember. The results displayed by the program will support that. The code (along with comments should be self explanatory). I wrote the code with simplicity in mind so that even a beginner in C++ should find it easy to read. However, if anything is not clear, feel free to comment and I will reply as soon as I can. ```c++ #include using namespace std; int main() { // Assign a value to a 32-bit so that we can view each of the four bytes // and read their addresses in memory. unsigned int i = 0x12345678; // char is 1 byte, so we will use it to read each of the 4 bytes in the // integer memory location. unsigned char* c = (unsigned char*)&i; // Show the value of the integer and the address in memory. // Take note of the address for comparing with other addresses displayed // for each of the bytes displayed below. cout << endl << "Value of i :\t0x" << hex << i << endl; cout << "Address of i :\t" << &i << endl << endl; // Show the address and value of the first byte. cout << "Address of c : \t0x" << (int)(c) << endl; cout << "Value of c[0] :\t0x" << hex << (int)(*c) << ", Address = 0x" << hex << (int)c << endl; c++; // Move to the 2nd byte cout << "Value of c[1] :\t0x" << hex << (int)(*c) << ", Address = 0x" << hex << (int)c << endl; c++; // Move to 3rd byte. cout << "Value of c[2] :\t0x" << hex << (int)(*c) << ", Address = 0x" << hex << (int)c << endl; c++; // Move 4th (last) byte. cout << "Value of c[3] :\t0x" << hex << (int)(*c) << ", Address = 0x" << hex << (int)c << endl; return 0; } ``` Running the program on my computer will show the following results: ``` Value of i : 0x12345678 Address of i : 0x6afee8 Address of c : 0x6afee8 Value of c[0] : 0x78, Address = 0x6afee8 Value of c[1] : 0x56, Address = 0x6afee9 Value of c[2] : 0x34, Address = 0x6afeea Value of c[3] : 0x12, Address = 0x6afeeb ``` ## Analysis What is important to take from the results is the following: 1. The least significant byte (LSB) of the integer is stored in a low memory address. This is what is expected since the system is little endian. The LSB is the one with value ```0x78```. 1. In each of the bytes, the bit order is not changed i.e., the high byte has the value ```0x12``` not ```0x21``` I have included a diagram below to show a visual representation if the bytes in memory, with low addresses at the bottom: ``` <> <> + + + + +----------+ + 12 + 0x6afeeb +----------+ + 34 + 0x6afeea +----------+ + 56 + 0x6afee9 +----------+ + 78 + 0x6afee8 +----------+ + + + + ``` That's it for this post. :)