Dynamic memory: malloc, free, and realloc

Stack memory vs heap memory

• Normal local variables live on the stack. They appear when a function starts and vanish when it returns.
• Sometimes you need memory that outlives the function, or whose size you only know at run time.
• That memory comes from the heap. You ask for it, and later you give it back.

malloc and sizeof

• malloc asks the heap for a block of bytes and returns a pointer to it.
• Use sizeof to get the size of one item: malloc(n * sizeof(int)) makes room for n ints.
• The block is yours to use through the pointer, exactly like an array: a[0], a[1], ...

free and memory leaks

• When you are done with heap memory, give it back with free(pointer).
• If you never free it, the program leaks memory — it holds space it no longer uses.
• Rule for these tasks: your function allocates and returns; the checker frees it. Do not call free yourself.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *a = malloc(3 * sizeof(int));   // room for 3 ints
    a[0] = 5; a[1] = 6; a[2] = 7;
    printf("%d\n", a[0] + a[1] + a[2]); // 18
    free(a);                            // give it back
    return 0;
}

Growing an array with realloc

• realloc(a, newSize) resizes a heap block, keeping the old contents.
• It may move the block, so always use its return value: a = realloc(a, ...).
• This is how you grow an array one item at a time, like a list that gets longer.

Now you try

• Use malloc(n * sizeof(int)) for new arrays, and #include <stdlib.h>.
• Your function returns the pointer; the checker frees it — do not call free. Do not write a main.