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.

Practice

1. What does little-endian mean in terms of byte order?

easy

A. Bytes are stored in reverse alphabetical order

B. The largest byte is stored first in memory

C. Bytes are stored in random order

D. The smallest byte is stored first in memory

Solution

1. Step 1: Understand byte order concept

   Little-endian means the smallest byte (least significant) is stored at the lowest memory address.

2. Step 2: Compare with big-endian

   Big-endian stores the largest byte first, so little-endian is the opposite.

3. Final Answer:

   The smallest byte is stored first in memory -> Option D

4. Quick Check:

   Little-endian = smallest byte first [OK]

Hint: Little-endian starts with smallest byte first [OK]

Common Mistakes:

• Confusing little-endian with big-endian
• Thinking bytes are stored randomly
• Mixing up byte significance order

2. Which of the following C code snippets correctly checks if the system is little-endian?

easy

A. int x = 1; char *c = (char*)&x; if (*c == 1) printf("Little-endian\n");

B. int x = 1; char *c = (char*)&x; if (*c == 0) printf("Little-endian\n");

C. int x = 256; char *c = (char*)&x; if (*c == 1) printf("Little-endian\n");

D. int x = 256; char *c = (char*)&x; if (*c == 0) printf("Little-endian\n");

Solution

1. Step 1: Understand the test logic

   Setting int x=1 stores 0x00000001 in memory. In little-endian, lowest byte is 1.

2. Step 2: Check pointer dereference

   Pointer to char reads first byte. If *c == 1, system is little-endian.

3. Final Answer:

   int x = 1; char *c = (char*)&x; if (*c == 1) printf("Little-endian\n"); -> Option A

4. Quick Check:

   Check first byte == 1 means little-endian [OK]

Hint: Check first byte of int 1 for 1 to detect little-endian [OK]

Common Mistakes:

• Using wrong value for x
• Checking *c == 0 instead of 1
• Confusing pointer types

3. Given the 32-bit hex number 0x12345678 stored in memory on a little-endian system, what is the byte order in memory (from lowest to highest address)?

medium

A. 12 34 56 78

B. 78 56 34 12

C. 34 12 78 56

D. 56 78 12 34

Solution

1. Step 1: Understand little-endian byte order

   Little-endian stores the least significant byte first. For 0x12345678, bytes are 12, 34, 56, 78.

2. Step 2: Arrange bytes in memory order

   Memory order is 78 (lowest address), 56, 34, 12 (highest address).

3. Final Answer:

   78 56 34 12 -> Option B

4. Quick Check:

   Little-endian reverses byte order [OK]

Hint: Little-endian reverses byte order from hex [OK]

Common Mistakes:

• Reading bytes in normal hex order
• Mixing big-endian and little-endian
• Confusing byte significance

4. The following code attempts to print the bytes of an integer in big-endian order on any system. What is the bug?

void print_big_endian_bytes(int x) {
  unsigned char *p = (unsigned char*)&x;
  for (int i = 0; i < 4; i++) {
    printf("%02x ", p[i]);
  }
  printf("\n");
}

medium

A. It prints bytes in system's native order, not big-endian

B. Pointer type is incorrect, should be int*

C. Loop runs too many times causing overflow

D. printf format specifier is wrong for bytes

Solution

1. Step 1: Analyze byte printing logic

   The code prints bytes from lowest to highest address, which is system native order.

2. Step 2: Identify missing conversion

   To print big-endian, bytes must be printed from highest to lowest address on little-endian systems.

3. Final Answer:

   It prints bytes in system's native order, not big-endian -> Option A

4. Quick Check:

   Printing p[i] from 0 to 3 prints native order [OK]

Hint: Print bytes reversed for big-endian on little-endian [OK]

Common Mistakes:

• Assuming pointer type causes bug
• Ignoring byte order differences
• Thinking printf format is wrong

5. You receive a 16-bit number from a big-endian device as two bytes: 0x01 and 0x02. Your little-endian system reads these bytes into memory in order. How do you correctly reconstruct the original number in C?

hard

A. int num = bytes[0] + bytes[1];

B. int num = (bytes[1] << 8) | bytes[0];

C. int num = (bytes[0] << 8) | bytes[1];

D. int num = bytes[1] * 256 + bytes[0];

Solution

1. Step 1: Understand byte order from big-endian device

   Big-endian sends most significant byte first: 0x01 then 0x02.

2. Step 2: Combine bytes correctly on little-endian system

   Shift first byte left 8 bits and OR with second byte: (0x01 << 8) | 0x02 = 0x0102.

3. Final Answer:

   int num = (bytes[0] << 8) | bytes[1]; -> Option C

4. Quick Check:

   Shift MSB left 8 bits, OR with LSB [OK]

Hint: Shift first byte left 8 bits, OR with second byte [OK]

Common Mistakes:

• Swapping byte order incorrectly
• Adding bytes instead of bitwise OR
• Ignoring device byte order