Dynamic Memory

What is static memory?

Static memory allocation means the amount of memory is decided at compile time and cannot change while the program runs. Ordinary variables, fixed-size arrays, and globals all work this way.

int x;              /* one int — size fixed at compile time */
int a[100];         /* always 100 ints, even if you use 3 */
char name[50];      /* always 50 bytes */

• Size known before running — the compiler reserves it
• Automatic cleanup — locals disappear when the block ends
• Lives on the stack (locals) or in the data segment (globals/statics)
• Cannot resize — a[100] can never become a[200]

What is dynamic memory?

Dynamic memory allocation means requesting memory at run time, after you know how much you actually need. The memory comes from a region called the heap and stays yours until you explicitly release it.

#include <stdlib.h>

int n;
scanf("%d", &n);              /* size decided by the user */

int *a = malloc(n * sizeof(*a));
if (a == NULL) return 1;      /* allocation can fail */

/* ... use a[0] .. a[n-1] ... */

free(a);                       /* you must release it */
a = NULL;

• Size decided while running — exactly what you need
• Lives on the heap — survives until free
• Accessed only through a pointer
• Manual cleanup — forgetting free causes a memory leak
• Can be resized with realloc

Static vs dynamic memory

Implementing dynamic memory in C

All four functions live in <stdlib.h>:

malloc — allocate raw bytes:

int *p = malloc(5 * sizeof(*p));   /* room for 5 ints */
if (p == NULL) {
    printf("allocation failed\n");
    return 1;
}
/* contents are garbage — write before reading */

calloc — allocate and zero:

int *q = calloc(5, sizeof(*q));   /* 5 ints, all 0 */

realloc — grow or shrink:

int *tmp = realloc(p, 10 * sizeof(*p));
if (tmp != NULL)
    p = tmp;        /* never assign realloc directly to p */

free — release it:

free(p);
p = NULL;         /* avoid a dangling pointer */

calloc() vs malloc()

/* These two request the same amount of memory */
int *a = malloc(10 * sizeof(int));  /* values: garbage */
int *b = calloc(10, sizeof(int));  /* values: all 0   */

Dynamic arrays — 1D

A dynamic array is just a pointer to a heap block treated as consecutive elements. You index it exactly like a normal array.

int n, i;
int *a;

printf("How many elements? ");
scanf("%d", &n);

a = malloc(n * sizeof(*a));
if (a == NULL) return 1;

for (i = 0; i < n; i++)
    scanf("%d", &a[i]);      /* a[i] works normally */

free(a);
a = NULL;

Growing it later with realloc:

int *tmp = realloc(a, (n * 2) * sizeof(*a));
if (tmp == NULL) {
    /* old block still valid — handle the error */
} else {
    a = tmp;
    n = n * 2;   /* existing values are preserved */
}

Dynamic arrays — 2D

Method A — array of row pointers (int **):

int **m;
int i, rows = 3, cols = 4;

m = malloc(rows * sizeof(*m));       /* array of row pointers */
for (i = 0; i < rows; i++)
    m[i] = malloc(cols * sizeof(**m));  /* each row */

m[1][2] = 99;                          /* normal 2D syntax */

/* free in reverse order: rows first, then the outer array */
for (i = 0; i < rows; i++)
    free(m[i]);
free(m);

Method B — one flat contiguous block:

int *m = malloc(rows * cols * sizeof(*m));

m[1 * cols + 2] = 99;   /* row 1, column 2 */

free(m);                     /* one allocation, one free */

Stack vs heap — where memory comes from

realloc in detail

• Existing contents are preserved up to the smaller of the old and new sizes
• When growing, the extra bytes are uninitialized (not zeroed)
• The block may be moved — the old pointer becomes invalid
• realloc(NULL, n) behaves like malloc(n)
• On failure it returns NULL and the original block is untouched

/* WRONG — leaks the original block if realloc fails */
p = realloc(p, newSize);

/* RIGHT — keep the old pointer until success is confirmed */
int *tmp = realloc(p, newSize);
if (tmp == NULL) {
    /* p is still valid; recover or exit */
} else {
    p = tmp;
}

Memory leaks

A leak happens when you lose the last pointer to a block you never freed. The memory stays reserved for the life of the process.

int *p = malloc(100 * sizeof(*p));
p = malloc(200 * sizeof(*p));   /* LEAK: first block is unreachable */

/* Also a leak: returning early without freeing */
if (error)
    return 1;                    /* forgot free(p) */

• Free before overwriting a pointer that owns memory
• Free on every exit path, including error returns
• In a loop, a small leak per iteration becomes a large one quickly

Dangling pointers, double free, and use-after-free

free(p);
p = NULL;     /* now free(p) again is harmless, and if (p) works */

Allocating strings and structs

/* String buffer: remember +1 for '\0' */
char *s = malloc((len + 1) * sizeof(*s));
if (s != NULL) {
    strcpy(s, "hello");
    free(s);
}

/* One struct */
struct Point { int x, y; };

struct Point *pt = malloc(sizeof(*pt));
pt->x = 3;
pt->y = 4;
free(pt);

/* Array of structs */
struct Point *pts = calloc(n, sizeof(*pts));

Returning heap memory from a function

Unlike a local array, heap memory outlives the function — so returning the pointer is safe. The caller then owns it and must free it.

/* SAFE — heap block survives the return */
int *makeArray(int n) {
    int *a = calloc(n, sizeof(*a));
    return a;    /* caller must free it */
}

/* UNSAFE — local dies at return, pointer dangles */
int *bad(void) {
    int a[10];
    return a;    /* undefined behavior */
}

Common mistakes