Исполняемые доки C: стандартная библиотека

Q: В чём разница между stdio.h и stdlib.h?

— это ввод и вывод: printf, scanf, fopen, fgets, FILE. — это утилиты общего назначения: malloc и free, atoi и strtol, rand и srand, exit, qsort, bsearch. Типичная программа подключает оба.

Q: Для чего нужен ctype.h?

Он классифицирует и преобразует отдельные символы: isdigit, isalpha, isalnum, isspace, isupper, islower, ispunct, плюс toupper и tolower. Использовать их вместо самописных сравнений вроде c >= '0' && c <= '9' понятнее и корректно для любой локали и любой кодировки.

Q: Нужно ли что-то линковать, чтобы использовать стандартную библиотеку C?

Нет, с одним исключением — математическими функциями. Стандартная библиотека C линкуется автоматически, но в Linux реализации из лежат в отдельной библиотеке, так что sqrt и компании требуют -lm в конце команды компиляции. Всему остальному нужен только правильный #include.

Язык C крошечный: типы, операторы, управляющие конструкции, функции, указатели. Он не умеет ни печатать, ни читать файл, ни сравнить строку, ни выделить память. Всё это — стандартная библиотека: набор заголовков, который поставляет каждая соответствующая стандарту реализация.

Эта страница — карта. Каждый раздел говорит, для чего нужен заголовок, показывает один короткий рабочий пример и указывает на более подробную страницу там, где она есть.

stdio.h — ввод и вывод

Заголовок, который вы подключаете первым почти в каждой программе. В нём живут printf и scanf, тип FILE и функции работы с файлами, а также более безопасные построчные функции ввода.

#include <stdio.h>

int main(void) {
    printf("Форматированный вывод: %d %s %.2f %c\n", 42, "текст", 3.14159, 'X');

    /* fputs пишет, не интерпретируя спецификаторы формата */
    fputs("Простой вывод, без форматирования\n", stdout);

    /* stderr - отдельный поток для диагностики */
    fprintf(stderr, "Это уходит в стандартный поток ошибок\n");

    /* putchar пишет один символ */
    for (char c = 'a'; c <= 'e'; c++) {
        putchar(c);
    }
    putchar('\n');
    return 0;
}

Самое необходимое: printf, fprintf, sprintf, snprintf для вывода; scanf, fscanf, sscanf, fgets, getchar для ввода; fopen, fclose, fread, fwrite, fseek для файлов. Подробнее — в printf, scanf и работе с файлами.

Одно правило стоит унести с собой: никогда не используйте gets(). Он никак не может узнать размер вашего буфера и был удалён из стандарта в C11. Замена — fgets(buf, sizeof buf, stdin).

stdlib.h — утилиты общего назначения

Сборная солянка: память, преобразования, случайные числа, управление процессом, сортировка.

#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) {
    /* строка в число */
    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"));

    /* динамическая память */
    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 сортирует что угодно, если дать ей функцию сравнения */
    qsort(nums, 5, sizeof *nums, compare_ints);
    for (int i = 0; i < 5; i++) {
        printf("%d ", nums[i]);
    }
    printf("\n");

    free(nums);
    return 0;
}

Главное: malloc, calloc, realloc, free (см. динамическую память); atoi, atof, strtol, strtod для преобразований — предпочитайте семейство strto*, которое умеет сообщать об ошибке там, где atoi молча возвращает 0; rand и srand (см. случайные числа); exit, abort, getenv, system; а также qsort/bsearch.

string.h — строки и блоки памяти

Строки в C — это массивы char, заканчивающиеся '\0', и каждая операция над ними есть вызов функции.

#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);

    /* функции mem* работают с сырыми байтами, а не только с текстом */
    char block[10];
    memset(block, '-', 9);
    block[9] = '\0';
    printf("memset  : %s\n", block);
    return 0;
}

Две привычки не дают этому заголовку превратиться в источник переполнений буфера: всегда знайте размер приёмника и помните, что strcmp возвращает 0 при равенстве — if (strcmp(a, b)) истинно, когда строки различаются. Функции для строк подробно разбирают более безопасные приёмы со strncpy/snprintf.

math.h — математика

sqrt, pow, fabs, floor, ceil, round, fmod, семейства тригонометрических и логарифмических функций, INFINITY и 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;
}

Это единственный заголовок, которому может понадобиться флаг компоновщика: в Linux добавьте -lm в конец команды компиляции, иначе компоновщик сообщит "undefined reference to sqrt". Полный обзор — в математических функциях.

time.h — часы и даты

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

int main(void) {
    time_t now = time(NULL);
    printf("Секунд с 1970 года: %ld\n", (long) now);
    printf("Местное время: %s", ctime(&now));

    struct tm *lt = localtime(&now);
    printf("Год: %d, месяц: %d, день: %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("Отформатировано: %s\n", buf);

    /* clock() измеряет процессорное время, потраченное этой программой */
    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("Цикл занял %.4f секунд CPU\n", secs);
    return 0;
}

Два смещения в struct tm ловят всех: tm_year отсчитывается от 1900 года, а tm_mon нумеруется с нуля. time(NULL) к тому же обычно служит зерном для srand.

ctype.h — классификация символов

Маленький и куда более полезный, чем кажется. Каждая функция принимает символ и отвечает на вопрос «да или нет» либо меняет регистр.

#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("букв=%d цифр=%d пробелов=%d знаков препинания=%d\n",
           letters, digits, spaces, punct);

    printf("В верхнем регистре: ");
    for (const char *p = text; *p != '\0'; p++) {
        putchar(toupper((unsigned char) *p));
    }
    printf("\n");
    return 0;
}

Полный набор: isalpha, isdigit, isalnum, isspace, isupper, islower, ispunct, isxdigit, isprint, плюс toupper и tolower.

Обратите внимание на приведение (unsigned char). Эти функции определены для значений, представимых как unsigned char, плюс EOF; обычный char на большинстве систем знаковый, поэтому байт больше 127 приходит отрицательным числом и вызов становится неопределённым поведением. Приведение ничего не стоит и снимает целый класс проблем.

И предпочитайте их самодельным проверкам. c >= '0' && c <= '9' случайно работает, но isdigit(c) говорит о том, что вы имеете в виду, и остаётся корректным везде.

limits.h и float.h — границы типов

Насколько большим может быть int на этой машине? Эти заголовки отвечают на вопрос, и именно поэтому переносимый код спрашивает, а не предполагает.

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

int main(void) {
    printf("char  : от %d до %d (%zu байт)\n", CHAR_MIN, CHAR_MAX, sizeof(char));
    printf("int   : от %d до %d (%zu байт)\n", INT_MIN, INT_MAX, sizeof(int));
    printf("long  : от %ld до %ld (%zu байт)\n", LONG_MIN, LONG_MAX, sizeof(long));
    printf("uint  : от 0 до %u\n", UINT_MAX);

    printf("float : от %g до %g (%zu байт)\n", FLT_MIN, FLT_MAX, sizeof(float));
    printf("double: от %g до %g (%zu байт)\n", DBL_MIN, DBL_MAX, sizeof(double));
    printf("у double %d десятичных знаков точности\n", DBL_DIG);
    return 0;
}

INT_MAX — это способ проверить переполнение до того, как оно произойдёт, и это важно, потому что знаковое переполнение — неопределённое поведение, а не обёртывание, которое можно проверить постфактум.

stdbool.h и stdint.h — типы получше

До C99 в C не было логического типа. <stdbool.h> его даёт:

#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 и false — это макросы для _Bool, 1 и 0, но они делают намерение очевидным. (В C23 они стали ключевыми словами, и заголовок больше не нужен.)

<stdint.h> даёт типы с гарантированной разрядностью — незаменимые для форматов файлов, сетевых протоколов и всего встраиваемого, где «int, наверное, 32-битный» недостаточно хорошо:

#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("размеры: %zu %zu %zu %zu\n",
           sizeof small, sizeof port, sizeof count, sizeof big);
    return 0;
}

Макросы вида PRId32 из <inttypes.h> разворачиваются в правильный спецификатор printf для каждого типа фиксированной ширины на текущей платформе — это и есть переносимый способ их печатать, ведь %d подходит для int32_t на одних системах и не подходит на других.

assert.h — проверка ваших предположений

assert(expr) не делает ничего, когда выражение истинно, и аварийно завершает программу с сообщением, когда оно ложно.

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

int divide(int a, int b) {
    assert(b != 0);          /* контракт: вызывающие не должны передавать 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) здесь завершил бы программу с сообщением:
       Assertion `b != 0' failed. */
    return 0;
}

Компиляция с -DNDEBUG убирает все проверки, так что в релизной сборке они ничего не стоят. В этом же и предупреждение: никогда не помещайте побочный эффект внутрь assert. assert(read_next() > 0) в релизной сборке вообще перестаёт читать, и получившийся баг проявляется только в продакшене.

Проверки предназначены для ваших ошибок — для условий, которые должны быть невозможны, если код корректен. Плохой ввод пользователя — не повод для assert; это if и сообщение об ошибке.

Остальное, кратко

<stddef.h> — size_t, ptrdiff_t, NULL, offsetof
<stdarg.h> — функции с переменным числом аргументов, механика, стоящая за printf
<errno.h> — errno плюс perror и strerror, чтобы сообщить, почему вызов не удался
<signal.h> — обработка сигналов, например Ctrl-C
<setjmp.h> — нелокальные переходы; редко бывают правильным ответом
<locale.h>, <wchar.h>, <wctype.h> — локали и широкие символы
<stdnoreturn.h>, <stdalign.h>, <threads.h>, <stdatomic.h> — дополнения C11

Две привычки делают библиотеку приятной в использовании. Читайте man-страницу, а не угадывайте сигнатуру — man 3 strtol на macOS и Linux авторитетен и быстр. И проверяйте возвращаемые значения: malloc, fopen и strtol все сообщают о неудаче, а программа, которая их игнорирует, ломается гораздо позже и гораздо менее понятным образом.

Часто задаваемые вопросы

Что такое стандартная библиотека C?

Это набор функций, типов и макросов, которые предоставляет каждая соответствующая стандарту реализация C, сгруппированных примерно в 30 заголовков. Он покрывает ввод и вывод (<stdio.h>), память и преобразования (<stdlib.h>), строки (<string.h>), математику (<math.h>), время, классификацию символов и пределы числовых типов. В самом языке C нет ни встроенного ввода-вывода, ни работы со строками — всё это отсюда.

В чём разница между stdio.h и stdlib.h?

<stdio.h> — это ввод и вывод: printf, scanf, fopen, fgets, FILE. <stdlib.h> — это утилиты общего назначения: malloc и free, atoi и strtol, rand и srand, exit, qsort, bsearch. Типичная программа подключает оба.

Для чего нужен ctype.h?

Он классифицирует и преобразует отдельные символы: isdigit, isalpha, isalnum, isspace, isupper, islower, ispunct, плюс toupper и tolower. Использовать их вместо самописных сравнений вроде c >= '0' && c <= '9' понятнее и корректно для любой локали и любой кодировки.

Нужно ли что-то линковать, чтобы использовать стандартную библиотеку C?

Нет, с одним исключением — математическими функциями. Стандартная библиотека C линкуется автоматически, но в Linux реализации из <math.h> лежат в отдельной библиотеке, так что sqrt и компании требуют -lm в конце команды компиляции. Всему остальному нужен только правильный #include.

Связанные концепции