For multi-byte variables as int, it matters how this sequence of bytes is stored in the memory. The two possibilities are little endian and big endian.

But first, let's recap, how hexadecimal values are written and interpreted and how their bits are stored. The following variable i is of type integer and uses four bytes of storage:

int i = 0x12345678;

The digits are called nibble, each having a value of 0 to f (representing 15). In this example, the 8 is the least significant digit, its value is factored with ${16}^0=1$. The next digit from the right, 7, must be multiplied with ${16}^1=16$, thus it adds the value $7\cdot 16=112$. The other nibbles are handled accordingly up to the leftmost (8th) place (value 1), having a factor of ${16}^7=\mathrm{268\hspace{0.17em}435\hspace{0.17em}456}$.

Each nibble can easily be converted to binary because there are only 16 different values. For example: 8 = 0b1000. When those are written piece by piece, the hex value can be converted to binary:

0x12345678
= 0x    1    2    3    4    5    6    7    8
= 0b 0001 0010 0011 0100 0101 0110 0111 1000

As in decimal numbers, the least significant bit is far to the right and the most significant bit is left. Bitfields are usually displayed with bit 0 (the least significant) to the right and with increasing bit positions to the left.

Little endian

Systems using little endian byte order store the least significant byte at the lowest address.

int i = 0x12345678;

As in decimal numbers, the rightmost digit (8) is the least significant and the leftmost digit (1) is the most significant. Two hexadecimal digits (two nibbles) are stored in one byte:

This becomes twisted, if multiple bytes are displayed in a row. If the bytes in the row are numbered increasing from right to left, the above sequence of digits can be recognized easily:

But if the bytes are numbered (more intuitively) from left to right, the sequence of pairs is reversed:

Note, that only the bytes (pairs of hexadecimal digits) are in a different sequence, each pair for itself remains with its less significant digit on the right side (similar to decimal numbers like 42). Some Hex-Viewers show pairs of bytes (short, words) -- when these are stored in little endian format and displayed from left to right, they show up: 5678 1234.

The first version appears preferable, at least for multi-byte integers. With character strings, this is different:

char str[] = "Hello world";

This is comparable to an array with the letter H in the first element, i.e. the lowest address. Placing this string behind the variable i and showing addresses increasing from right to left:

In the case of strings, increasing addresses from left to right (as one reads english text) is favorable (by twisting the integer, again):

Big endian

In big endian, the least significant byte is stored at the largest address:

In this byte order, addresses are usually displayed increasing from left to right as this allows to read the multi-byte integer as well as the string:

Network byte order

Documents, that are exchanged between systems and especially network transmissions should care for the byte order. In the internet protocols, a network byte order is defined (which is big endian). There are functions to convert network byte order to the host byte order:

#include <netinet/in.h>
unsigned long htonl(unsigned long hostlong)   // host to network, long (32 bit)
unsigned long ntohl(unsigned long netlong)    // network to host, long (32 bit)

Programming

When does a program need to care for endianess?

Of course, when exchanging data with other instances (other programs or the same program running on a different system) either via files or network, the byte order matters. Only if all systems use the same byte order (for example, all are x86 systems), it can be ignored.

The internet protocol (BSD sockets) libraries use network byte order and require the IP address to be converted with htonl().

In internal data structures, the byte order matters if unions or pointers are used to access portions of other variables. As long as only math operations and casts are used, it can be ignored:

union {
    uint32_t u32;
    uint8_t  u8[4];
} demo;

demo.u32 = 0x12345678;
/*
 * using the address, it depends on the byte ordering, what comes out.
 */
printf("lowest address: u8[0] = %hhx \n", demo.u8[0]);
printf("highest address: u8[3] = %hhx \n", demo.u8[3]);
/*
 * using math operations, the least significant byte can be masked or calculated
 * independently from the byte ordering.
 */
printf("least significant byte: %hhx \n", demo.u32 % 256);              // modulo 
printf("least significant byte: %hhx \n", demo.u32 & 0xff);             // bitwise AND
printf("most significant byte: %hhx \n", demo.u32 / (256 * 256 * 256)); // division
printf("most significant byte: %hhx \n", demo.u32 >> 24);               // bit shift

(download this code.)

Further reading

• Little-endian vs. big-endian (discusses trade-offs and current trends)