Memory Operations in C

Byte-Level Copying Using memcpy

The memcpy function copies a specified number of bytes from a source buffer to a destination buffer.

Signature: void* memcpy(void* dest, const void* src, size_t count);

Unlike strcpy, which halts upon encountering a null terminator, memcpy operates purely on byte counts and handles any data type. However, it exhibits undefined behavior if the source and destination regions overlap.

Custom Implementation

void* byte_copy(void* target, const void* origin, size_t bytes) {
    if (!target || !origin) return NULL;
    unsigned char* t_ptr = (unsigned char*)target;
    const unsigned char* o_ptr = (const unsigned char*)origin;
    for (size_t i = 0; i < bytes; ++i) {
        t_ptr[i] = o_ptr[i];
    }
    return target;
}

Safe Overlapping Copies with memmove

Signature: void* memmove(void* dest, const void* src, size_t count);

To resolve the overlapping memory issue present in memcpy, the C standard library provides memmove. It guarantees correct data transfer regardless of whether the source and destination buffers intersect, effectively acting as a safer superset of memcpy.

Custom Implementation

void* safe_move(void* target, const void* origin, size_t bytes) {
    unsigned char* t_ptr = (unsigned char*)target;
    const unsigned char* o_ptr = (const unsigned char*)origin;
    if (t_ptr > o_ptr && t_ptr < o_ptr + bytes) {
        for (size_t i = bytes; i > 0; --i) {
            t_ptr[i - 1] = o_ptr[i - 1];
        }
    } else {
        for (size_t i = 0; i < bytes; ++i) {
            t_ptr[i] = o_ptr[i];
        }
    }
    return target;
}

Memory Initialization with memset

Signature: void* memset(void* dest, int c, size_t count);

This utility fills the first count bytes of the memory block pointed to by dest with the byte value c.

Byte-Wise Comparison with memcmp

Signature: int memcmp(const void* buf1, const void* buf2, size_t count);

This function compares the first count bytes of two memory regions. It returns a value less than zero if the first differing byte in buf1 is smaller than in buf2, greater than zero if it is larger, and zero if both regions are identical up to the specified length.

Endianness and Byte Order

Endianness dictates the sequence in which multi-byte data types are stored in memory. It defines whether the most significant byte (MSB) or the least significant byte (LSB) occupies the lowest memory address.

• Big-Endian: The MSB is stored at the lowest memory address, and the LSB is stored at the highest.
• Little-Endian: The LSB is stored at the lowest memory address, and the MSB is stored at the highest.

Detecting System Endianness

A system's byte order can be determined by examining the first byte of an integer value. By assigning a value of 1 to a multi-byte integer and checking its lowest address, a value of 1 indicates Little-Endian, while 0 indicates Big-Endian.

#include <stdio.h>

int detect_endianness() {
    unsigned int val = 0x01;
    return *(unsigned char*)&val;
}

int main() {
    if (detect_endianness() == 1) {
        printf("Little Endian\n");
    } else {
        printf("Big Endian\n");
    }
    return 0;
}