The C Standard Library: A Map of the Headers Worth Knowing

C the language is tiny - types, operators, control flow, functions, pointers. It cannot print, read a file, compare a string, or allocate memory. All of that is the standard library: a set of headers that every conforming implementation ships.

This page is a map. Each section says what a header is for, shows one short working example, and points to the fuller page where one exists.

stdio.h - Input and Output

The header you include first in almost every program. It holds printf and scanf, the FILE type and the file functions, and the safer line-oriented input functions.

#include <stdio.h>

int main(void) {
    printf("Formatted: %d %s %.2f %c\n", 42, "text", 3.14159, 'X');

    /* fputs writes without interpreting format specifiers */
    fputs("Plain output, no formatting\n", stdout);

    /* stderr is a separate stream for diagnostics */
    fprintf(stderr, "This goes to standard error\n");

    /* putchar writes a single character */
    for (char c = 'a'; c <= 'e'; c++) {
        putchar(c);
    }
    putchar('\n');
    return 0;
}

The essentials: printf, fprintf, sprintf, snprintf for output; scanf, fscanf, sscanf, fgets, getchar for input; fopen, fclose, fread, fwrite, fseek for files. Deeper coverage lives in printf, scanf, and file handling.

One rule worth carrying: never use gets(). It has no way to know the size of your buffer and was removed from the standard in C11. fgets(buf, sizeof buf, stdin) is the replacement.

stdlib.h - General Utilities

The catch-all: memory, conversions, randomness, process control, sorting.

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

int compare_ints(const void *a, const void *b) {
    int x = *(const int *)a;
    int y = *(const int *)b;
    return (x > y) - (x < y);
}

int main(void) {
    /* string to number */
    printf("atoi(\"123\")     = %d\n", atoi("123"));
    printf("strtol(\"ff\", 16) = %ld\n", strtol("ff", NULL, 16));
    printf("atof(\"3.5\")     = %.2f\n", atof("3.5"));

    /* dynamic memory */
    int *nums = malloc(5 * sizeof *nums);
    if (nums == NULL) {
        return 1;
    }
    int seed_values[] = {50, 10, 40, 20, 30};
    for (int i = 0; i < 5; i++) {
        nums[i] = seed_values[i];
    }

    /* qsort sorts anything given a comparison function */
    qsort(nums, 5, sizeof *nums, compare_ints);
    for (int i = 0; i < 5; i++) {
        printf("%d ", nums[i]);
    }
    printf("\n");

    free(nums);
    return 0;
}

Highlights: malloc, calloc, realloc, free (see dynamic memory); atoi, atof, strtol, strtod for conversions - prefer the strto* family, which can report failure where atoi silently returns 0; rand and srand (see random numbers); exit, abort, getenv, system; and qsort/bsearch.

string.h - Strings and Memory Blocks

C strings are arrays of char ending in '\0', and every operation on them is a function call.

#include <stdio.h>
#include <string.h>

int main(void) {
    char dest[64] = "Hello";

    printf("strlen  : %zu\n", strlen(dest));

    strcat(dest, ", world");
    printf("strcat  : %s\n", dest);

    printf("strcmp  : %d\n", strcmp("apple", "banana"));
    printf("strchr  : %s\n", strchr(dest, 'w'));
    printf("strstr  : %s\n", strstr(dest, "world"));

    char copy[64];
    strcpy(copy, dest);
    printf("strcpy  : %s\n", copy);

    /* the mem* functions work on raw bytes, not just text */
    char block[10];
    memset(block, '-', 9);
    block[9] = '\0';
    printf("memset  : %s\n", block);
    return 0;
}

Two habits keep this header from becoming a source of buffer overflows: always know the destination's size, and remember that strcmp returns 0 for equality - if (strcmp(a, b)) is true when the strings differ. String functions covers the safer strncpy/snprintf patterns in detail.

math.h - Mathematics

sqrt, pow, fabs, floor, ceil, round, fmod, the trig and log families, INFINITY and NAN.

#include <stdio.h>
#include <math.h>

int main(void) {
    printf("sqrt(2)     = %.6f\n", sqrt(2.0));
    printf("pow(2, 10)  = %.0f\n", pow(2.0, 10.0));
    printf("ceil(4.1)   = %.0f\n", ceil(4.1));
    printf("fabs(-9.5)  = %.1f\n", fabs(-9.5));
    return 0;
}

This is the one header that may need a linker flag: on Linux, add -lm at the end of the compile command or the linker reports "undefined reference to sqrt". Full tour in [math functions](/docs/c/math-functions).

time.h - Clocks and Dates

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

int main(void) {
    time_t now = time(NULL);
    printf("Seconds since 1970: %ld\n", (long) now);
    printf("Local time: %s", ctime(&now));

    struct tm *lt = localtime(&now);
    printf("Year: %d, month: %d, day: %d\n",
           lt->tm_year + 1900, lt->tm_mon + 1, lt->tm_mday);

    char buf[64];
    strftime(buf, sizeof buf, "%Y-%m-%d %H:%M:%S", lt);
    printf("Formatted: %s\n", buf);

    /* clock() measures processor time used by this program */
    clock_t start = clock();
    volatile long sum = 0;
    for (long i = 0; i < 3000000L; i++) {
        sum += i;
    }
    double secs = (double)(clock() - start) / CLOCKS_PER_SEC;
    printf("Loop took %.4f CPU seconds\n", secs);
    return 0;
}

The two offsets in struct tm catch everyone: tm_year counts from 1900, and tm_mon is 0-based. time(NULL) is also the usual seed for srand.

ctype.h - Character Classification

Small, and more useful than it looks. Each function takes a character and answers a yes/no question, or converts case.

#include <stdio.h>
#include <ctype.h>

int main(void) {
    const char *text = "Coddy C17, launched!";

    int letters = 0, digits = 0, spaces = 0, punct = 0;
    for (const char *p = text; *p != '\0'; p++) {
        unsigned char c = (unsigned char) *p;
        if (isalpha(c))      letters++;
        else if (isdigit(c)) digits++;
        else if (isspace(c)) spaces++;
        else if (ispunct(c)) punct++;
    }
    printf("letters=%d digits=%d spaces=%d punctuation=%d\n",
           letters, digits, spaces, punct);

    printf("Upper: ");
    for (const char *p = text; *p != '\0'; p++) {
        putchar(toupper((unsigned char) *p));
    }
    printf("\n");
    return 0;
}

The full set: isalpha, isdigit, isalnum, isspace, isupper, islower, ispunct, isxdigit, isprint, plus toupper and tolower.

Notice the (unsigned char) cast. These functions are defined for values representable as unsigned char plus EOF; a plain char is signed on most systems, so a byte above 127 arrives as a negative number and the call becomes undefined behavior. The cast costs nothing and removes the whole class of problem.

And prefer these over hand-rolled tests. c >= '0' && c <= '9' happens to work, but isdigit(c) says what you mean and stays correct everywhere.

limits.h and float.h - The Edges of the Types

How big can an int get on this machine? These headers answer it, and the answers are why portable code asks instead of assuming.

#include <stdio.h>
#include <limits.h>
#include <float.h>

int main(void) {
    printf("char  : %d to %d (%zu byte)\n", CHAR_MIN, CHAR_MAX, sizeof(char));
    printf("int   : %d to %d (%zu bytes)\n", INT_MIN, INT_MAX, sizeof(int));
    printf("long  : %ld to %ld (%zu bytes)\n", LONG_MIN, LONG_MAX, sizeof(long));
    printf("uint  : 0 to %u\n", UINT_MAX);

    printf("float : %g to %g (%zu bytes)\n", FLT_MIN, FLT_MAX, sizeof(float));
    printf("double: %g to %g (%zu bytes)\n", DBL_MIN, DBL_MAX, sizeof(double));
    printf("double has %d decimal digits of precision\n", DBL_DIG);
    return 0;
}

INT_MAX is how you check for overflow before it happens, which matters because signed overflow is undefined behavior rather than a wraparound you can test for afterwards.

stdbool.h and stdint.h - Better Types

C had no boolean type until C99. <stdbool.h> supplies one:

#include <stdio.h>
#include <stdbool.h>

bool is_even(int n) {
    return n % 2 == 0;
}

int main(void) {
    bool ready = true;
    bool done  = false;

    printf("ready=%d done=%d\n", ready, done);
    printf("is_even(10) = %s\n", is_even(10) ? "true" : "false");
    return 0;
}

bool, true and false are macros for _Bool, 1 and 0, but they make intent obvious. (In C23 they became keywords and the header is no longer required.)

<stdint.h> gives types with guaranteed widths - essential for file formats, network protocols, and anything embedded, where "an int is probably 32 bits" is not good enough:

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

int main(void) {
    int8_t   small = -128;
    uint16_t port  = 8080;
    int32_t  count = 2000000000;
    uint64_t big   = 18000000000000000000ULL;

    printf("int8_t  : %" PRId8  "\n", small);
    printf("uint16_t: %" PRIu16 "\n", port);
    printf("int32_t : %" PRId32 "\n", count);
    printf("uint64_t: %" PRIu64 "\n", big);

    printf("sizes: %zu %zu %zu %zu\n",
           sizeof small, sizeof port, sizeof count, sizeof big);
    return 0;
}

The PRId32-style macros from <inttypes.h> expand to the correct printf specifier for each fixed-width type on the current platform - which is the portable way to print them, since %d is right for int32_t on some systems and wrong on others.

assert.h - Checking Your Assumptions

assert(expr) does nothing when the expression is true and aborts the program with a message when it is false.

#include <stdio.h>
#include <assert.h>

int divide(int a, int b) {
    assert(b != 0);          /* a contract: callers must not pass 0 */
    return a / b;
}

int main(void) {
    printf("20 / 4 = %d\n", divide(20, 4));
    printf("20 / 5 = %d\n", divide(20, 5));

    /* divide(20, 0) here would abort with:
       Assertion `b != 0' failed. */
    return 0;
}

Compiling with -DNDEBUG removes every assertion, so they cost nothing in a release build. That is also the warning: never put a side effect inside an assert. assert(read_next() > 0) stops reading entirely in the release build, and the resulting bug appears only in production.

Assertions are for your mistakes - conditions that should be impossible if the code is correct. Bad user input is not an assertion; it is an if and an error message.

The Rest, Briefly

• <stddef.h> - size_t, ptrdiff_t, NULL, offsetof
• <stdarg.h> - variadic functions, the machinery behind printf
• <errno.h> - errno plus perror and strerror for reporting why a call failed
• <signal.h> - handling signals such as Ctrl-C
• <setjmp.h> - non-local jumps; rarely the right answer
• <locale.h>, <wchar.h>, <wctype.h> - locales and wide characters
• <stdnoreturn.h>, <stdalign.h>, <threads.h>, <stdatomic.h> - C11 additions

Two habits make the library pleasant to use. Read the manual page before guessing at a signature - man 3 strtol on macOS and Linux is authoritative and fast. And check return values: malloc, fopen, and strtol all report failure, and a program that ignores them fails much later and much less clearly.