Endianness (big-endian vs little-endian) in Embedded C - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this code snippet?

Consider the following C code that checks the endianness of the system:

unsigned int x = 0x12345678;
char *c = (char*)&x;
printf("%02x %02x %02x %02x", (unsigned char)c[0], (unsigned char)c[1], (unsigned char)c[2], (unsigned char)c[3]);

What will be printed on a little-endian system?

Embedded C

unsigned int x = 0x12345678;
char *c = (char*)&x;
printf("%02x %02x %02x %02x", (unsigned char)c[0], (unsigned char)c[1], (unsigned char)c[2], (unsigned char)c[3]);

A 00 00 00 00

B 12 34 56 78

C 78 56 34 12

D 78 34 56 12

💡 Hint

Think about how bytes are stored in memory on little-endian systems.

In little-endian systems, the least significant byte is stored first. So 0x12345678 is stored as 78 56 34 12 in memory.

❓ Predict Output

intermediate

What is the output of this code snippet on a big-endian system?

Given the same code as before:

unsigned int x = 0x12345678;
char *c = (char*)&x;
printf("%02x %02x %02x %02x", (unsigned char)c[0], (unsigned char)c[1], (unsigned char)c[2], (unsigned char)c[3]);

What will be printed on a big-endian system?

Embedded C

unsigned int x = 0x12345678;
char *c = (char*)&x;
printf("%02x %02x %02x %02x", (unsigned char)c[0], (unsigned char)c[1], (unsigned char)c[2], (unsigned char)c[3]);

A 12 34 56 78

B 78 56 34 12

C 00 00 00 00

D 34 12 78 56

💡 Hint

Recall how big-endian systems store the most significant byte first.

Big-endian systems store the most significant byte first, so 0x12345678 is stored as 12 34 56 78 in memory.

🧠 Conceptual

advanced

Which statement correctly describes endianness?

Choose the correct statement about endianness in computer systems.

A Little-endian stores the least significant byte at the lowest memory address.

B Big-endian stores the least significant byte at the highest memory address.

C Little-endian stores the most significant byte at the lowest memory address.

D Endianness only affects how data is displayed on the screen.

💡 Hint

Think about which byte is stored first in memory for little-endian systems.

Little-endian systems store the least significant byte at the lowest memory address, while big-endian systems store the most significant byte first.

🔧 Debug

advanced

What error occurs when this code runs on a little-endian system?

Consider this code snippet that tries to convert a 4-byte array to an integer:

unsigned char bytes[4] = {0x12, 0x34, 0x56, 0x78};
unsigned int *p = (unsigned int*)bytes;
printf("%x", *p);

What problem might occur on a little-endian system?

A The printed value will be 0x12345678, which matches the byte order.

B The printed value will be 0x78563412, which is incorrect for the intended value.

C The code causes a segmentation fault due to invalid pointer casting.

D The code causes a compile-time error due to incompatible types.

💡 Hint

Think about how the bytes are interpreted when cast to an integer pointer on little-endian.

The bytes are stored as 12 34 56 78. On little-endian, *p interprets it as 0x78563412 (LSB first), but if intended as big-endian serialization of 0x12345678, it's incorrect.

🚀 Application

expert

How to write a portable function to swap endianness of a 32-bit integer?

Which of the following C functions correctly swaps the byte order of a 32-bit unsigned integer (converts big-endian to little-endian or vice versa)?

A

unsigned int swap_endian(unsigned int val) {
  return (val << 24) | (val << 8) | (val >> 8) | (val >> 24);
}

B

unsigned int swap_endian(unsigned int val) {
  return (val & 0xFF) << 24 | (val & 0xFF00) << 8 | (val & 0xFF0000) >> 8 | (val & 0xFF000000) >> 24;
}

C

unsigned int swap_endian(unsigned int val) {
  return val ^ 0xFFFFFFFF;
}

D

unsigned int swap_endian(unsigned int val) {
  return ((val >> 24) & 0x000000FF) |
         ((val >> 8) & 0x0000FF00) |
         ((val << 8) & 0x00FF0000) |
         ((val << 24) & 0xFF000000);
}

💡 Hint

Think about shifting and masking each byte to its new position.

Option D correctly shifts and masks each byte to swap the endianness. Option D incorrectly shifts without masking, causing bits to overlap. Option D just flips bits, not bytes. Option D has incorrect masking and shifting order.