§14.1–14.3Types of Memory … The free() Call

Second interlude — short and pointy, as the book promises all chapters are (this one more than most).

14.1 Types of Memory

A running C program has two kinds of memory. Stack memory — a.k.a. automatic memory automatic memory Stack memory — allocated and freed implicitly by the compiler at function call/return; don't keep long-lived data there. defined in ch. 14 — open in glossary — is managed implicitly by the compiler:

void func() {
  int x; // declares an integer on the stack
  ...
}

Space appears when func() is called and vanishes when it returns — so information that must outlive the call had better not live there. That need is what the heap is for, where allocation and deallocation are handled explicitly, by you. A heavy responsibility, and the cause of many bugs — the next page’s whole gallery of them. Here’s the heap version, and it’s sneakier than it looks:

void func() {
  int *x = (int *) malloc(sizeof(int));
  ...
}

That single line allocates memory twice — step through it:

14.2 The malloc() Call

malloc() malloc The C library call requesting heap bytes (size via sizeof()); returns a pointer, or NULL on failure. A library call, not a system call. defined in ch. 14 — open in glossary is simple: pass a size, receive a pointer to fresh heap space — or NULL on failure. man malloc tells you everything:

#include <stdlib.h>
...
void *malloc(size_t size);

(You don’t strictly need the header — libc has the code regardless — but including it lets the compiler check you’re calling it correctly.) Nobody types raw byte counts; use sizeof():

double *d = (double *) malloc(sizeof(double));

That’s a lot of double-ing. Note that sizeof() is a compile-time operator, not a function — the 8 is substituted before the program ever runs. And it has a famous trap:

int *x = malloc(10 * sizeof(int));   // an array of 10 ints — fine
printf("%d\n", sizeof(x));           // prints 4 or 8. NOT 40!

int y[10];
printf("%d\n", sizeof(y));           // prints 40 — enough static info

sizeof(x) asks how big a pointer is; the compiler has no idea what that pointer refers to. Strings have their own idiom — malloc(strlen(s) + 1) — the +1 for the end-of-string character (sizeof may mislead you here too). And the (int *) cast? Pure reassurance for compiler and reader — “yeah, I know what I’m doing” — not needed for correctness.

14.3 The free() Call

Allocation, it turns out, is the easy half. To release heap memory:

int *x = malloc(10 * sizeof(int));
...
free(x);

free() free Releases a malloc'd region — pointer only, no size (the library tracks it). Knowing when/how/if to call it is the hard part. defined in ch. 14 — open in glossary takes just the pointer — no size. The allocation library tracks how big each region is (a detail with real consequences when chapter 17 builds such a library). Knowing when, how, and even if to free — that’s the hard part, and the source of the bug gallery that awaits in the next section.