Dynamic memory: malloc, free, and realloc

Stack memory vs heap memory

• Ordinary non-static local variables have automatic storage duration: their lifetime ends when their block finishes. Implementations usually put them on the stack; C does not require a particular memory layout.
• 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)) requests room for n ints. Check for NULL before using them; newly allocated values are uninitialised. Here sizes are small and positive, so the byte calculation fits.
• 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
    if (a == NULL) return EXIT_FAILURE;
    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

• For a positive byte size, realloc(a, newSize) preserves the first min(oldSize, newSize) bytes when it succeeds. Newly added cells need initialising.
• On failure it returns NULL and leaves the old allocation intact. Save the result in a temporary pointer; overwriting your only pointer with NULL loses access to the old block.
• On success use only the returned pointer: the block may have moved. Avoid zero-size realloc here because its rules differ between C versions.

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

int main(void) {
    int *a = malloc(2 * sizeof *a);
    if (a == NULL) return EXIT_FAILURE;
    a[0] = 4; a[1] = 9;
    int *grown = realloc(a, 3 * sizeof *a);
    if (grown == NULL) {
        free(a);  // the old allocation still belongs to us
        return EXIT_FAILURE;
    }
    a = grown;
    a[2] = 16;
    printf("%d %d %d\n", a[0], a[1], a[2]); // 4 9 16
    free(a);
    return 0;
}

Common mistakes

• Every malloc needs a matching free; do not use memory after free.
• Check allocation results before dereferencing. A failed growth must not change the recorded length or free the caller's old array.

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.