Спецификаторы формата в C: полный справочник по printf и scanf

Спецификатор формата говорит printf, как превратить значение в текст, а scanf — как превратить текст в значение. Это единственная часть C, где компилятор по умолчанию не может вам помочь: типы аргументов для функции невидимы, — поэтому данная страница и есть та таблица, с которой стоит сверяться.

Общий вид спецификации такой:

%[флаги][ширина][.точность][длина]преобразование

Обязательны только % и буква преобразования. %-8.2lf использует все пять частей.

Таблица преобразований

#include <stdio.h>

int main(void) {
    int x = 255;

    printf("%%d  : %d\n", x);
    printf("%%u  : %u\n", x);
    printf("%%x  : %x\n", x);
    printf("%%X  : %X\n", x);
    printf("%%o  : %o\n", x);
    printf("%%c  : %c\n", 65);
    printf("%%s  : %s\n", "текст");
    printf("%%f  : %f\n", 3.5);
    printf("%%e  : %e\n", 3.5);
    printf("%%g  : %g\n", 3.5);
    printf("%%p  : %p\n", (void *)&x);
    return 0;
}

Две записи заслуживают предупреждения. %n пишет в память, а не печатает, и именно он лежит в основе уязвимости строки формата — никогда не позволяйте пользовательскому тексту попадать в строку формата. А %p требует void *; передача int * напрямую формально не определена, хотя любой реальный компилятор всё равно напечатает адрес.

Модификаторы длины

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

Знаковые преобразования (d i) и беззнаковые (u x o) принимают разные типы: %lu хочет unsigned long, а не long, и ошибка здесь — это неопределённое поведение, а не косметическая небрежность.

А для семейств чисел с плавающей точкой и символов:

Комбинации, которые вы действительно набираете:

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

int main(void) {
    short              s   = -12;
    long               l   = 3000000000L;
    long long          ll  = 9000000000000000000LL;
    unsigned long      ul  = 4000000000UL;
    unsigned long long ull = 18000000000000000000ULL;
    size_t             len = strlen("hello");
    long double        ld  = 2.5L;

    printf("short              : %hd\n", s);
    printf("long               : %ld\n", l);
    printf("long long          : %lld\n", ll);
    printf("unsigned long      : %lu\n", ul);
    printf("unsigned long long : %llu\n", ull);
    printf("size_t             : %zu\n", len);
    printf("long double        : %Lf\n", ld);
    return 0;
}

%zu — тот случай, который стоит запомнить. sizeof, strlen и любой размер из стандартной библиотеки возвращают size_t, который на 64-битной системе занимает 8 байт, тогда как int — 4. printf("%d", strlen(s)) — настоящий баг, который на некоторых платформах кажется работающим; используйте %zu.

Модификаторы hh и h существуют в основном ради scanf, где важен размер приёмника. В printf short повышается до int ещё до вызова, поэтому %d напечатал бы его правильно и так; %hd лишь документирует намерение.

Типы фиксированной ширины

Для типов из <stdint.h>, таких как int32_t, переносимые спецификаторы — это макросы из <inttypes.h>:

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

int main(void) {
    int32_t  a = -2000000000;
    uint64_t b = 18000000000000000000ULL;

    printf("int32_t  : %" PRId32 "\n", a);
    printf("uint64_t : %" PRIu64 "\n", b);
    return 0;
}

PRId32 разворачивается в нужные для вашей платформы буквы, а соседние строковые литералы склеиваются — вот почему формат разбит на три куска. Выглядит это уродливо; альтернатива — привести значение к long long и использовать %lld — часто читабельнее и всегда корректна.

Флаги

Флаги ставятся сразу после % и меняют представление. Они применимы только к printf.

#include <stdio.h>

int main(void) {
    printf("|%6d|\n",   42);
    printf("|%-6d|\n",  42);
    printf("|%06d|\n",  42);
    printf("|%+d|\n",   42);
    printf("|% d|\n",   42);
    printf("|%#x|\n",  255);
    printf("|%#o|\n",   64);
    printf("|%#.0f|\n", 3.0);
    return 0;
}

Флаги комбинируются: %-+8.2f — это минимальная ширина 8, два знака после точки, всегда со знаком, дополнение после числа. Если написать и -, и 0, побеждает -.

Ширина и точность

Ширина — это минимальный размер поля: вывод дополняется до неё и никогда не обрезается ради неё. Точность (после точки) означает разное для разных семейств:

#include <stdio.h>

int main(void) {
    printf("|%10.3f|\n", 3.14159);     /* ширина 10, 3 знака после точки */
    printf("|%.5d|\n",   42);          /* минимум 5 цифр       */
    printf("|%.3s|\n",   "abcdefg");   /* не более 3 символов  */
    printf("|%.0f|\n",   2.71828);     /* без дробной части    */
    printf("|%*d|\n",    8, 42);       /* ширина из аргумента */
    printf("|%.*f|\n",   3, 3.14159);  /* точность из аргумента */
    return 0;
}

* вместо любого из этих чисел берёт его из аргумента типа int, который читается перед самим значением. Именно так строят таблицы, ширина столбцов которых вычисляется во время выполнения.

В scanf у ширины другая и гораздо более важная роль: она ограничивает количество поглощаемого ввода, и это единственное, что стоит между %s и переполнением буфера.

Чем printf и scanf различаются

Они выглядят похоже и расходятся в четырёх местах. Каждое из них — живой источник багов:

#include <stdio.h>

int main(void) {
    double d;
    char   word[16];

    printf("Введите десятичное число и слово: ");
    if (scanf("%lf %15s", &d, word) == 2) {   /* %lf и ширина */
        printf("%.3f и \"%s\"\n", d, word);   /* %f и точность */
    } else {
        printf("Ввод не подошёл.\n");
    }
    return 0;
}

Попробуйте 2.5 привет. Формат, который его читает, и формат, который его печатает, используют разные буквы для одного и того же double, а 15 в %15s ограничивает ввод пятнадцатью символами плюс завершающий ноль — ровно размер word.

Набор символов в scanf

%[...] читает набор символов, а не слово, ограниченное пробелами. Это способ прочитать целую строку через scanf, хотя fgets остаётся лучшим инструментом:

#include <stdio.h>

int main(void) {
    char line[64];

    printf("Введите предложение: ");
    if (scanf("%63[^\n]", line) == 1) {     /* всё до перевода строки */
        printf("Вы ввели: %s\n", line);
    }
    return 0;
}

[^\n] означает «любые символы, кроме перевода строки». %[0-9] читал бы только цифры, %[abc] — только эти три буквы. В отличие от %s, набор символов не пропускает ведущие пробельные символы, поэтому оставшийся в буфере перевод строки приведёт к тому, что он не сопоставится вообще ни с чем.

Ошибка здесь — это неопределённое поведение

printf не видит настоящего типа вашего аргумента. Он читает ровно столько байтов, сколько подразумевает спецификатор, и интерпретирует их так, как тот говорит. Поэтому несовпадение — это не сбой форматирования, а чтение памяти не как того, чем она является:

printf("%d\n", 3.5);        /* печатает мусор: биты double читаются как int */
printf("%s\n", 42);         /* трактует 42 как адрес - падение */
printf("%d\n", strlen(s));  /* size_t читается как int - неверно на 64 битах */
printf("%f\n", 3);          /* int читается как double - мусор */

Защита стоит одного флага. Компилируйте с -Wall — и GCC сверит каждую литеральную строку формата с её аргументами:

gcc -Wall -Wextra program.c -o program

Он сообщит о каждой из четырёх строк выше ещё на этапе компиляции. Это самое ценное предупреждение в C, и в редакторе выше оно включено по умолчанию.

Практическую сторону — выровненные таблицы, читаемый вывод чисел с плавающей точкой, чтение ввода без классического бага с переводом строки — смотрите в статьях printf и scanf.