Step 1 of 10

Stack vs heap

Every variable you've made so far lives on the stack. The stack is fast and automatic: a function's local variables are created when it's called and destroyed when it returns. But it has two big limits:

Sizes are fixed when you write the code. int scores[100] is always 100, even if you only need 3, or need 1,000. (C99 added variable-length arrays whose size is chosen at run time, but they're optional in newer standards and a large one can overflow the stack, which is small: typically 1 to 8 MB.)
Lifetimes are tied to the function. When a function returns, its locals are gone, so it can't create data that outlives it.

The heap removes both limits. It's a large pool of memory you request while the program runs, of any size, and it stays yours until you give it back.

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

int main(void) {
    int n = 4;
    double *temps = malloc(n * sizeof(double));
    if (temps == NULL) {
        return 1;
    }
    for (int i = 0; i < n; i++) {
        temps[i] = 20.5 + i;
    }
    printf("%.1f %.1f\n", temps[0], temps[n - 1]);
    free(temps);
    return 0;
}

20.5 23.5

The pieces

#include <stdlib.h> declares malloc and free.
malloc(bytes) reserves that many bytes on the heap and returns a pointer to the start. It knows nothing about types, so you compute the size: count x sizeof the element. malloc(n) alone would be n bytes, not n doubles, a very common bug.
The returned pointer can be used exactly like an array: temps[i].
malloc returns NULL if the memory isn't available. Always check before using it.
free(pointer) gives the block back. After that you must not touch it.

The rule of thumb: every successful malloc gets exactly one free. Use the Watch it run link to see the heap block appear, fill, and disappear.

Your task

Allocate room for n ints.

Challenge 2

Allocate room for n doubles with calloc, which also sets every byte to zero. Set only the second price, print the first two, and free the memory. The output is 0.00 4.50.

Challenge 3

Allocate an array of 10 ints on the heap yourself, fill it with the squares 0, 1, 4, ..., 81, print their sum as sum 285, and free it. Check that the allocation worked.

Next: Size decided at runtime