C Example – Little Endian and Big Endian

Little and Big Endian are two different byte orderings used to represent multibyte data types, such as integers, in computer memory.

Pre-Request to read this first: What is Little and Big Endian in System

The choice between Both is crucial when data is transferred between systems with different byte orderings. Network protocols and file formats often specify the byte order to ensure compatibility between systems. Many modern architectures, especially those based on x86 and x86-64, use Little-Endian by default.

Littele Endian	Big Endian
In a Little Endian system, the least significant byte (the one with the smallest memory address) is stored first.	In a Big Endian system, the most significant byte (the one with the smallest memory address) is stored first.
It’s like reading a number from right to left, with the rightmost digit being the least significant.	It’s like reading a number from left to right, with the leftmost digit being the most significant.
Commonly used in x86 and x86-64 architectures.	older architectures: such as the Motorola 68k, use Big Endian.

Program to find the machine is which type?

The idea is to create a union with a multi-byte data type and check the value of the first byte. Here’s an example:

#include <stdio.h>
int main() 
{
   unsigned int i = 1;
   char *c = (char*)&i;
   if (*c)    
       printf("Little endian");
   else
       printf("Big endian");
   return 0;
}

/* Output : Depends upon the computer memory design */

Compile and run the program to determine the endianness of the machine

Conversion in C++

for Visual C++ there is _byteswap_ulong()

//COnvert Little to Big Endian
#include <stdio.h>
#include <inttypes.h>
int main()
{
    uint32_t le = 0x12345678;
    uint32_t be = __builtin_bswap32(le);
    printf("Little-endian: 0x%" PRIx32 "\n", le);
    printf("Big-endian:    0x%" PRIx32 "\n", be);
    return 0;
}

/* Output
Little-endian: 0x12345678
Big-endian:    0x78563412
*/

Certainly! Here’s an example code snippet in C++ that you can use to converting for a 32-bit integer. You can use this as a concise and clear example for an interview:

#include <iostream>
#include <cstdint>

// Convert 32-bit Little Endian to Big Endian
uint32_t convertLittleToBigEndian32(uint32_t littleEndianValue) {
    return ((littleEndianValue & 0xFF000000) >> 24) |
           ((littleEndianValue & 0x00FF0000) >> 8) |
           ((littleEndianValue & 0x0000FF00) << 8) |
           ((littleEndianValue & 0x000000FF) << 24);
}

int main() {
    uint32_t littleEndianValue = 0x12345678;

    std::cout << "Original Little Endian: 0x" << std::hex << littleEndianValue << std::endl;

    uint32_t bigEndianValue = convertLittleToBigEndian32(littleEndianValue);

    std::cout << "Converted Big Endian:   0x" << std::hex << bigEndianValue << std::endl;

    return 0;
}

This code includes a function convertLittleToBigEndian32 that performs the conversion. During an interview, you can explain the bitwise operations used for the conversion and discuss any additional considerations for different data types. This example showcases the fundamental principles of endianness conversion.

Conversion in C

//This below code is run in little endian
//Converting  Little to Big-Endian
#include <stdio.h>

int main()
{
    int Aew_result = 0xAABBCCDD, b0,b1,b2,b3;
    printf("Big-endian\t :0x%x" "\n", Aew_result);

    b0 = (Aew_result & 0xff) << 24;        // least significant to most significant
    b1 = (Aew_result & 0xff00) << 8;       // 2nd least sig. to 2nd most sig.
    b2 = (Aew_result & 0xff0000) >> 8;     // 2nd most sig. to 2nd least sig.
    b3 = (Aew_result & 0xff000000) >> 24;  // most sig. to least sig.
    Aew_result = b0 | b1 | b2 | b3 ;

    printf("Little-endian\t :0x%x" "\n", Aew_result);

    return 0;
}

/* OutPut
Big-endian       :0xaabbccdd
Little-endian    :0xddccbbaa
*/

Memory Map representation

#include <stdio.h>

int main()
{
    unsigned int i = 0xAABBCCDD;
    unsigned int n = sizeof(i);
    char *p = (char*) &i;
    
    while(n)
    {
        printf("%x\n",*p);
        p++;
        n--;
    }
    
    return 0;
}

/* Output
ffffffdd
ffffffcc
ffffffbb
ffffffaa
*/