Pointers and dynamic memory allocation notes — Unit 4

When you declare `int x = 5;`, the computer finds a random empty locker in RAM (say, locker number 2048), puts the number 5 inside it, and labels the locker 'x'.

A Pointer is just a variable that holds a LOCKER NUMBER (a memory address) instead of normal data.

Pointers rely entirely on two operators. Mastering them is 90% of the battle.

• 1. `&` (Address-Of Operator): Returns the memory address of a variable.
• 2. `*` (Dereference Operator): Goes to the address stored in a pointer, and grabs the value inside it.

int x = 10;      // x is 10. Assume x is at address 5000.
int *p = &x;     // p now stores the number 5000.

printf("%d", x);   // Prints 10 (Direct access)
printf("%d", &x);  // Prints 5000
printf("%d", p);   // Prints 5000
printf("%d", *p);  // Goes to 5000, grabs the value. Prints 10.

C declarations can get messy. The secret trick to reading any C declaration is to read it backwards (right-to-left).

We will use this trick heavily when dealing with double pointers and arrays of pointers later.

You can add and subtract numbers from pointers, but it does NOT work like normal math. Pointer math is automatically scaled by the `sizeof` the data type it points to.

Assume integer takes 4 bytes. Address of p is 1000.
int *p = 1000;
p = p + 1;
// What is p now? It is NOT 1001!

1. 1.1. The compiler sees `p + 1`.
2. 2.2. It checks what p points to: an `int`.
3. 3.3. It finds `sizeof(int)` = 4 bytes.
4. 4.4. The actual math it performs is: 1000 + (1 * 4) = 1004.

There are strict rules about what mathematical operations are legal on memory addresses.

Why is `p1 + p2` illegal? Because adding two random memory addresses (like 1000 + 4000 = 5000) gives you a completely meaningless, random location in RAM.

In C, arrays and pointers are almost the exact same thing. The compiler treats the name of an array as a constant pointer to its first element.

int arr[3] = {10, 20, 30};
// 'arr' is a constant pointer pointing to the '10'.

1. 1.Because `arr` is a pointer, `arr + 1` points to the next integer (the 20).
2. 2.If we want the value, we dereference it: `*(arr + 1)`.
3. 3.This is literally what the square bracket syntax does behind the scenes!

Because arr[i] means *(arr + i)
And addition is commutative *(i + arr)
You can legally write `i[arr]` instead of `arr[i]`. It compiles perfectly.

Predict the output of the following pointer traversal.

int arr[] = {10, 20, 30};
int *p = arr;

printf("%d ", *p);
printf("%d ", *(p+1));
printf("%d ", *p++);
printf("%d ", *p);

1. 1.1. `*p` prints the value at the current address (10).
2. 2.2. `*(p+1)` looks one slot ahead and prints it (20), but `p` ITSELF did not move.
3. 3.3. `*p++` is tricky. The postfix `++` happens AFTER the expression. So it prints the current value (10), and THEN moves the pointer `p` forward by one slot.
4. 4.4. `*p`. The pointer moved in the last step, so it now points to 20. Prints 20.

A string in C is just an array of characters, ending with a null terminator `\`. Therefore, a string can be manipulated using a `char *`.

char *p = "Code";
while(*p != '\') {
    printf("%c", *p);
    p++; // Move to next character
}

Normally, you must declare array sizes as constants: `int arr[100];`. If you only end up needing 5 slots, you wasted 95. If you need 105, your program crashes. This is 'Static Memory Allocation' (allocated on the Stack at compile time).

⇒The Solution: The Heap

Dynamic Memory Allocation (DMA) allows you to ask the Operating System for memory DURING runtime. This memory comes from a massive pool called the 'Heap'.

• `malloc()`: Memory Allocate
• `calloc()`: Contiguous Allocate
• `realloc()`: Re-allocate
• `free()`: Free memory

`malloc` takes one argument: the TOTAL number of bytes you want. It finds a block of that size on the Heap, and returns a `void *` (a generic pointer) to the start of it.

// I want an array of 'n' integers.
int n = 5;
int *arr;

// 5 integers * 4 bytes each = 20 bytes total.
arr = (int *)malloc(n * sizeof(int));

1. 1.Why the `(int )`? Because malloc returns a generic `void `. We must 'Typecast' it to tell the compiler: 'Treat this block as a sequence of integers.'
2. 2.Why `sizeof(int)`? Never hardcode '4'. Some old systems use 2 bytes for int. `sizeof` makes your code portable.

`calloc` does the exact same job as `malloc`, but with two key differences.

• 1. It takes TWO arguments: the number of items, and the size of one item.
• 2. It automatically initializes every single byte to ZERO (clears the garbage).

// I want an array of 5 integers, all set to 0.
int *arr;
arr = (int *)calloc(5, sizeof(int));

What if you ask for 50 Gigabytes of RAM, and the computer doesn't have it? The Operating System will deny the request. `malloc` and `calloc` will return a `NULL` pointer (address 0).

int *arr = (int *)malloc(100 * sizeof(int));

if (arr == NULL) {
    printf("Memory allocation failed!\n");
    exit(1); // Abort program
}

// If we get here, it's safe to use 'arr'.

Local variables on the Stack are automatically destroyed when a function ends. Heap memory is completely manual. It survives until the program ends, OR until you explicitly tell the OS you are done with it using `free()`.

int *arr = (int *)malloc(100 * sizeof(int));
// ... use the array ...
free(arr); // Give the memory back to the OS!

You used `malloc` for 5 integers. Suddenly, you realize you need 10 integers. You can't just expand an array normally, but you can use `realloc` to resize a Heap block.

int *arr = (int *)malloc(5 * sizeof(int));

// Need more space!
arr = (int *)realloc(arr, 10 * sizeof(int));

1. 1.How realloc works behind the scenes:
2. 2.1. It tries to just extend the current block if there is empty space next to it.
3. 3.2. If there is NO space, it finds a brand new block of size 10.
4. 4.3. It secretly COPIES your old data into the new block.
5. 5.4. It frees the old block automatically.
6. 6.5. It returns the new pointer address.

A pointer stores the address of a variable. But a pointer is ALSO a variable itself, meaning it has its own memory address! You can create a pointer that stores the address of another pointer. This is a Double Pointer (``).

int x = 10;       // x is at address 1000
int *p = &x;      // p holds 1000. p itself is at address 2000.
int **q = &p;     // q holds 2000.

1. 1.Dereferencing trace:
2. 2.q => gives 2000 (address of p)
3. 3.*q => goes to 2000, grabs value => 1000 (address of x)
4. 4.q => goes to 2000, grabs 1000, goes to 1000, grabs value => 10

Double pointers are heavily used in C when you want to pass a 2D array to a function, or when you want a function to modify a pointer itself.

A Dangling Pointer is a pointer that points to a memory location that has been deleted or given back to the OS. It's like having a key to a house that was demolished.

int *p = (int *)malloc(sizeof(int));
*p = 5;

free(p); // Memory is returned to OS.
// At this exact moment, 'p' is Dangling!

*p = 10; // SEGFAULT! Writing to deleted memory.

A `void ` is a generic pointer. It can store the address of ANY data type (int, float, char). `malloc` returns a `void ` because it doesn't know what you plan to store in the memory.

int x = 10;
float y = 5.5;
void *p;

p = &x; // Valid
p = &y; // Also valid!

You can create an array where every single slot holds a pointer. This is extremely useful for storing lists of strings without wasting space.

// A standard 2D array forces all rows to be the same width:
char names[3][10] = {"Bob", "Alice", "Christopher"};
// 'Bob' wastes 7 bytes of empty padding.

// An Array of Pointers:
char *names[3] = {"Bob", "Alice", "Christopher"};
// This just creates 3 pointers. Each pointer points to exactly 
// the required memory in the Data Segment. Zero wasted padding!

Just like variables, Functions live in memory (in the Code Segment). Therefore, functions have memory addresses! You can create a pointer to a function and call it through the pointer.

int add(int a, int b) { return a + b; }

int main() {
    // Declare a pointer 'ptr' to a function that takes two ints and returns int
    int (*ptr)(int, int) = &add;
    
    // Call the function via the pointer
    int result = ptr(5, 10);
}

This is an advanced feature used in operating systems and game engines to create 'Callback' functions (passing a function as an argument to another function).

⇒Unit 4 Mastery

• Do you understand why `*p++` increments the pointer and not the value?
• Can you explain why `arr[i]` and `*(arr + i)` are identical?
• Do you know the exact differences between `malloc` (garbage) and `calloc` (zeros)?
• Can you write the code to safely allocate memory and check for `NULL`?
• Do you know the difference between a Memory Leak and a Dangling Pointer?
• Can you read `int p` backwards to understand it?