C Standard Library stdlib.h

What You’ll Learn

<stdlib.h> is the “general utilities” header. It handles dynamic memory (malloc, free), ending your program (exit), turning text into numbers (strtol), random numbers (rand), and sorting arrays (qsort). If you have used stdio.h for I/O, stdlib.h is the natural next step for heap memory and helpers.

Definition and Usage

Stack arrays have a fixed size decided at compile time. malloc asks the operating system for memory at runtime and returns a void * you cast (in C, assignment to typed pointer works implicitly) to your data type. When finished, free returns that memory.

Beyond memory, stdlib.h offers process control (exit, abort, atexit), conversions (atoi, strtol, strtod), pseudo-random numbers (rand, srand), and algorithms (qsort, bsearch).

📝 Syntax

Include the header:

#include <stdlib.h>

Memory allocation

• malloc(size) — allocate size bytes (uninitialized)
• calloc(count, size) — allocate count * size bytes, zeroed
• realloc(ptr, new_size) — resize an existing block
• free(ptr) — release memory from malloc family

Process control

• exit(status) — terminate program; flush stdio buffers
• abort() — abnormal termination (may produce core dump)
• atexit(func) — register function called on normal exit
• EXIT_SUCCESS, EXIT_FAILURE — portable status codes

String conversion

• atoi(str), atof(str) — simple conversions, no error detail
• strtol(str, &end, base) — long integer with base and error pointer
• strtod(str, &end) — double with error pointer

Other common functions

• rand(), srand(seed), RAND_MAX
• qsort(base, count, size, compare) — sort array
• bsearch(key, base, count, size, compare) — binary search sorted array
• abs(n), labs(n) — absolute value

Typical allocation pattern

int *arr = malloc(n * sizeof *arr);
if (arr == NULL) {
    fprintf(stderr, "Out of memory\n");
    exit(EXIT_FAILURE);
}
/* use arr */
free(arr);
arr = NULL;

Headers and linking

• #include <stdlib.h> — linked automatically with the C library.
• Memory functions use size_t from <stddef.h> (included indirectly).
• Compile: gcc program.c -std=c11 -o program.

Examples Gallery

Compile with gcc file.c -std=c11 -o out. All memory examples check for NULL and call free.

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

int main(void) {
    size_t n = 5;
    size_t i;
    int *arr = malloc(n * sizeof *arr);

    if (arr == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        return EXIT_FAILURE;
    }

    for (i = 0; i < n; i++) {
        arr[i] = (int)(i + 1);
    }

    for (i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    free(arr);
    arr = NULL;

    return EXIT_SUCCESS;
}

1 2 3 4 5

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

int main(void) {
    size_t n = 5;
    size_t i;
    int *counts = calloc(n, sizeof *counts);

    if (counts == NULL) {
        return EXIT_FAILURE;
    }

    counts[2] = 10;
    counts[4] = 3;

    for (i = 0; i < n; i++) {
        printf("counts[%zu] = %d\n", i, counts[i]);
    }

    free(counts);
    return EXIT_SUCCESS;
}

counts[0] = 0
counts[1] = 0
counts[2] = 10
counts[3] = 0
counts[4] = 3

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

int main(void) {
    size_t capacity = 2;
    size_t count = 0;
    size_t i;
    int *data = malloc(capacity * sizeof *data);
    int *tmp;
    int values[] = { 10, 20, 30, 40 };

    if (data == NULL) {
        return EXIT_FAILURE;
    }

    for (i = 0; i < 4; i++) {
        if (count == capacity) {
            capacity *= 2;
            tmp = realloc(data, capacity * sizeof *data);
            if (tmp == NULL) {
                free(data);
                return EXIT_FAILURE;
            }
            data = tmp;
        }
        data[count++] = values[i];
    }

    for (i = 0; i < count; i++) {
        printf("%d ", data[i]);
    }
    printf("\n");

    free(data);
    return EXIT_SUCCESS;
}

10 20 30 40

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

int main(void) {
    const char *good = "12345";
    const char *bad = "12abc";
    char *end;
    long val;

    errno = 0;
    val = strtol(good, &end, 10);
    if (end == good || *end != '\0') {
        printf("'%s' is not a valid integer\n", good);
    } else {
        printf("Parsed '%s' -> %ld\n", good, val);
    }

    errno = 0;
    val = strtol(bad, &end, 10);
    if (end == bad || *end != '\0') {
        printf("'%s' is not a fully valid integer (stopped at '%s')\n",
               bad, end);
    } else {
        printf("Parsed '%s' -> %ld\n", bad, val);
    }

    /* Quick demo: atoi on same good string */
    printf("atoi(\"%s\") = %d\n", good, atoi(good));

    return EXIT_SUCCESS;
}

Parsed '12345' -> 12345
'12abc' is not a fully valid integer (stopped at 'abc')
atoi("12345") = 12345

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

int main(void) {
    int i;

    srand((unsigned)time(NULL));

    printf("Rolling a die 5 times:\n");
    for (i = 0; i < 5; i++) {
        int roll = rand() % 6 + 1;
        printf("  Roll %d: %d\n", i + 1, roll);
    }

    printf("RAND_MAX on this system: %d\n", RAND_MAX);

    return EXIT_SUCCESS;
}

Rolling a die 5 times:
  Roll 1: 4
  Roll 2: 1
  Roll 3: 6
  Roll 4: 2
  Roll 5: 5
RAND_MAX on this system: 32767

🚀 Common Use Cases

• Dynamic arrays — grow lists when input size is unknown at compile time.
• String buffers — build text piece by piece with realloc.
• Config parsing — strtol/strtod for numeric settings.
• Games and simulations — rand for dice, shuffles, or test data.
• Sorting data — qsort on arrays of any element type.
• Fatal errors — exit(EXIT_FAILURE) when recovery is impossible.

📝 Notes

• malloc does not zero memory; reading before writing is undefined behavior.
• Multiplying sizes for malloc can overflow—check n > SIZE_MAX / sizeof(T) for large n.
• Never free the same pointer twice; never use memory after free.
• exit runs atexit handlers and flushes stdio; abort does not guarantee cleanup.
• atoi/atof return 0 on failure—indistinguishable from a valid zero.
• qsort requires a comparison function; array must be sortable in memory as one block.

⚡ Optimization

Frequent small malloc/free calls can be slow. Pool allocations, reuse buffers, or over-allocate with realloc in batches when profiling shows heap pressure. calloc costs slightly more than malloc due to zeroing—use malloc when you overwrite every byte anyway. Prefer stack arrays when size is small and known at compile time.

💡 Best Practices