Endianness (big-endian vs little-endian) in Embedded C - Visual Side-by-Side Comparison

Concept Flow - Endianness (big-endian vs little-endian)

Start with multi-byte data

↓

Check system endianness

↓

Big-endian: store MSB first

↓

Little-endian: store LSB first

↓

Memory stores bytes in order

↓

Data read back accordingly

This flow shows how a system decides to store multi-byte data in memory either with the most significant byte first (big-endian) or least significant byte first (little-endian).

Execution Sample

Embedded C

unsigned int x = 0x12345678;
unsigned char *p = (unsigned char *)&x;
printf("Byte 0: %02x\n", p[0]);
printf("Byte 1: %02x\n", p[1]);

This code stores a 4-byte integer and prints the first two bytes in memory to show how bytes are ordered depending on endianness.

Execution Table

Step	Action	Memory Byte Index	Byte Value (hex)	Explanation
1	Store 0x12345678 in variable x	-	-	Variable x holds 4 bytes: 12 34 56 78
2	Pointer p points to x's first byte	-	-	p[0] points to first byte in memory for x
3	Read p[0]	0	78 (little-endian) or 12 (big-endian)	First byte in memory depends on endianness
4	Read p[1]	1	56 (little-endian) or 34 (big-endian)	Second byte in memory depends on endianness
5	Print bytes	-	-	Output shows byte order in memory
6	End	-	-	Program ends after printing bytes

💡 All bytes printed; program ends after showing memory byte order.

Variable Tracker

Variable	Initial	After Step 1	After Step 2	After Step 5	Final
x	undefined	0x12345678	0x12345678	0x12345678	0x12345678
p	undefined	undefined	address of x	address of x	address of x
p[0]	undefined	undefined	first byte of x in memory	printed value	printed value
p[1]	undefined	undefined	second byte of x in memory	printed value	printed value

Key Moments - 3 Insights

Why does p[0] print 0x78 on little-endian but 0x12 on big-endian?

Because little-endian stores the least significant byte (0x78) at the lowest memory address, which p[0] points to. Big-endian stores the most significant byte (0x12) first, so p[0] points there. See execution_table rows 3 and 4.

Is the value of x changed by endianness?

No, x holds the same number 0x12345678 in both cases. Only the order of bytes in memory differs. This is shown in variable_tracker where x remains constant.

Why do we use a char pointer to inspect bytes?

Because a char pointer accesses memory one byte at a time, letting us see the exact byte order stored. This is shown in execution_table step 2 and 3.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of p[0] on a little-endian system at step 3?

A 0x12

B 0x78

C 0x34

D 0x56

💡 Hint

Check execution_table row 3 under 'Byte Value (hex)' for little-endian.

At which step does the program print the bytes stored in memory?

A Step 2

B Step 4

C Step 5

D Step 6

💡 Hint

Look for the step mentioning 'Print bytes' in execution_table.

If we changed x to 0xAABBCCDD, what would p[1] be on a big-endian system at step 4?

A 0xBB

B 0xCC

C 0xAA

D 0xDD

💡 Hint

In big-endian, bytes are stored MSB first: AA BB CC DD. p[1] points to second byte.

Concept Snapshot

Endianness decides byte order in memory for multi-byte data.
Big-endian stores the most significant byte first.
Little-endian stores the least significant byte first.
Use a char pointer to inspect byte order.
Understanding endianness helps with data exchange and debugging.

Full Transcript

This lesson shows how computers store multi-byte numbers differently depending on endianness. We use a 4-byte integer 0x12345678 and a char pointer to look at each byte in memory. On little-endian systems, the least significant byte 0x78 is stored first, so p[0] reads 0x78. On big-endian systems, the most significant byte 0x12 is stored first, so p[0] reads 0x12. The variable x itself holds the same number in both cases; only the byte order in memory changes. This is important to know when working with low-level data or communicating between different systems.