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.

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.

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.

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!

Predict the output of the following pointer traversal.

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 *`.

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.

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).

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).

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()`.

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.

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 (``).

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.

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.

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

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.

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?