Deep Dive into C: Pointers, Memory Management & System Internals

Understanding how memory works under the hood is what separates an average programmer from an exceptional systems engineer. C gives you direct control over memory layout, making it the supreme language for understanding operating systems, compilers, and hardware interfaces.

---

The Memory Layout of a C Program

When a C program executes, its virtual address space is organized into distinct segments:

1. Text Segment (Code Segment): Contains the compiled machine instructions. It is read-only to prevent accidental modification.
2. Initialized Data Segment (Data): Stores global and static variables that have explicit non-zero initial values.
3. Uninitialized Data Segment (BSS): Stores global and static variables initialized to zero or uninitialized.
4. Heap Segment: Managed dynamically at runtime via malloc(), calloc(), realloc(), and freed via free(). Grows upwards toward higher memory addresses.
5. Stack Segment: Automatically allocated for function frames, local variables, and return addresses. Grows downwards toward lower memory addresses.

---

Demystifying Pointers and Pointer Arithmetic

A pointer is simply a variable whose value is the memory address of another variable.

#include <stdio.h>

int main() {
    int x = 42;
    int *ptr = &x; // ptr holds address of x

    printf("Value of x: %d
", x);
    printf("Address of x: %p
", (void*)&x);
    printf("Pointer ptr stores: %p
", (void*)ptr);
    printf("Dereferenced value (*ptr): %d
", *ptr);

    // Pointer Arithmetic
    int arr[3] = {10, 20, 30};
    int *pArr = arr; // Points to arr[0]

    printf("First element: %d
", *pArr);
    printf("Second element: %d
", *(pArr + 1)); // Advances by sizeof(int) bytes
    return 0;
}

---

Dynamic Memory Allocation: malloc vs calloc vs realloc

1. malloc(size_t size)

Allocates a contiguous block of specified bytes. Memory contents are uninitialized (contain garbage values).

2. calloc(size_t num, size_t size)

Allocates memory for an array of num elements and automatically zeroes out all bytes.

3. free(void *ptr)

Releases memory back to the heap to prevent memory leaks.

int *dynamicArr = (int*)malloc(5 * sizeof(int));
if (dynamicArr == NULL) {
    fprintf(stderr, "Memory allocation failed!
");
    return 1;
}

for (int i = 0; i < 5; i++) {
    dynamicArr[i] = (i + 1) * 10;
}

// Always free dynamically allocated memory
free(dynamicArr);
dynamicArr = NULL; // Prevent dangling pointer

---

Common Memory Pitfalls to Avoid

• Dangling Pointer: A pointer pointing to memory that has already been deallocated with free().
• Memory Leak: Allocating heap memory without freeing it, causing system memory consumption to grow indefinitely.
• Double Free: Calling free() on the same pointer twice, leading to undefined behavior or security vulnerabilities.
• Buffer Overflow: Writing past the allocated boundary of an array or memory block.