Specyfikatory formatu w C: pełna ściągawka printf i scanf

Specyfikator formatu mówi printf, jak zamienić wartość na tekst, a scanf, jak zamienić tekst na wartość. To jedyne miejsce w C, w którym kompilator domyślnie ci nie pomoże, bo funkcja nie widzi typów argumentów. Ta strona to tabela, z którą warto się porównywać.

Ogólny kształt specyfikacji wygląda tak:

%[flagi][szerokość][.precyzja][długość]konwersja

Wymagane są tylko % i litera konwersji. %-8.2lf używa wszystkich pięciu części.

Tabela konwersji

#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", "tekst");
    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;
}

Dwa wpisy wymagają ostrzeżenia. %n zapisuje do pamięci zamiast wypisywać i to na nim opiera się podatność format string: nigdy nie pozwól, żeby tekst od użytkownika trafił do łańcucha formatu. A %p wymaga void *; przekazanie int * bezpośrednio jest niezdefiniowane, choć każdy prawdziwy kompilator i tak wypisze adres.

Modyfikatory długości

Modyfikator długości stoi między precyzją a literą konwersji i mówi, jak duży jest naprawdę argument.

Konwersje ze znakiem (d i) i bez znaku (u x o) przyjmują różne typy: %lu oczekuje unsigned long, a nie long, a pomyłka to niezdefiniowane zachowanie, nie kosmetyczna wpadka.

A dla rodzin zmiennoprzecinkowej i znakowej:

Kombinacje, które naprawdę się wpisuje:

#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("czesc");
    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 warto zapamiętać. sizeof, strlen i każdy rozmiar z biblioteki standardowej zwracają size_t, który w systemie 64-bitowym ma 8 bajtów, podczas gdy int ma 4. printf("%d", strlen(s)) to prawdziwy błąd, który na niektórych platformach pozornie działa. Używaj %zu.

Modyfikatory hh i h istnieją głównie dla scanf, gdzie liczy się rozmiar miejsca docelowego. W printf wartość short jest promowana do int przed wywołaniem, więc %d i tak wypisze ją poprawnie; %hd tylko dokumentuje intencję.

Typy o stałej szerokości

Dla typów z <stdint.h>, takich jak int32_t, przenośne specyfikatory to makra z <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 rozwija się do liter właściwych dla twojej platformy, a sąsiadujące literały łańcuchowe łączą się ze sobą, dlatego format jest podzielony na trzy kawałki. Wygląda to brzydko; alternatywa, czyli rzutowanie na long long i użycie %lld, jest często czytelniejsza i zawsze poprawna.

Flagi

Flagi stoją tuż po % i zmieniają sposób prezentacji. Dotyczą tylko 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;
}

Flagi można łączyć: %-+8.2f to minimalna szerokość 8, dwa miejsca po przecinku, zawsze ze znakiem i z dopełnieniem za liczbą. Jeśli napiszesz jednocześnie - i 0, wygrywa -.

Szerokość i precyzja

Szerokość to minimalny rozmiar pola: wynik jest dopełniany, żeby ją osiągnąć, i nigdy nie jest obcinany, żeby się w niej zmieścić. Precyzja (po kropce) znaczy coś innego dla każdej rodziny:

#include <stdio.h>

int main(void) {
    printf("|%10.3f|\n", 3.14159);     /* szerokość 10, 3 miejsca po przecinku */
    printf("|%.5d|\n",   42);          /* co najmniej 5 cyfr   */
    printf("|%.3s|\n",   "abcdefg");   /* najwyżej 3 znaki     */
    printf("|%.0f|\n",   2.71828);     /* bez miejsc po przecinku */
    printf("|%*d|\n",    8, 42);       /* szerokość z argumentu */
    printf("|%.*f|\n",   3, 3.14159);  /* precyzja z argumentu */
    return 0;
}

* w miejscu którejkolwiek z tych liczb pobiera ją z argumentu int, odczytanego przed samą wartością. Tak buduje się tabele, których szerokości kolumn są obliczane w czasie działania programu.

W scanf szerokość ma inne i znacznie ważniejsze zadanie: ogranicza, ile danych wejściowych pochłonie konwersja, i tylko ona chroni %s przed przepełnieniem bufora.

Czym różnią się printf i scanf

Wyglądają podobnie, a nie zgadzają się w czterech miejscach. Każde z nich to realne źródło błędów:

#include <stdio.h>

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

    printf("Wpisz liczbe dziesietna i slowo: ");
    if (scanf("%lf %15s", &d, word) == 2) {   /* %lf i szerokość */
        printf("%.3f i \"%s\"\n", d, word);   /* %f i precyzja */
    } else {
        printf("Dane nie pasuja do formatu.\n");
    }
    return 0;
}

Wypróbuj 2.5 hello. Format, który to wczytuje, i format, który to wypisuje, używają różnych liter dla tego samego double, a 15 w %15s ogranicza wejście do 15 znaków plus terminator, czyli dokładnie do rozmiaru word.

Zbiór znaków w scanf

%[...] wczytuje zbiór znaków zamiast słowa oddzielonego białymi znakami. Tak wczytuje się całą linię przez scanf, choć fgets pozostaje lepszym narzędziem:

#include <stdio.h>

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

    printf("Wpisz zdanie: ");
    if (scanf("%63[^\n]", line) == 1) {     /* wszystko aż do znaku nowej linii */
        printf("Wpisano: %s\n", line);
    }
    return 0;
}

[^\n] oznacza "dowolne znaki poza znakiem nowej linii". %[0-9] wczyta tylko cyfry, a %[abc] tylko te trzy litery. W przeciwieństwie do %s zbiór znaków nie pomija początkowych białych znaków, więc zabłąkany znak nowej linii w buforze sprawia, że nie dopasuje niczego.

Pomyłka to niezdefiniowane zachowanie

printf nie widzi prawdziwego typu argumentu. Odczytuje tyle bajtów, ile sugeruje specyfikator, i interpretuje je tak, jak on każe. Niezgodność nie jest więc usterką formatowania, tylko odczytem pamięci jako czegoś innego:

printf("%d\n", 3.5);        /* wypisuje śmieci: czyta bity double jako int */
printf("%s\n", 42);         /* traktuje 42 jak adres: awaria */
printf("%d\n", strlen(s));  /* size_t czytany jako int: błąd na 64 bitach */
printf("%f\n", 3);          /* int czytany jako double: śmieci */

Obrona kosztuje jedną flagę. Kompiluj z -Wall, a GCC sprawdzi każdy dosłowny łańcuch formatu względem jego argumentów:

gcc -Wall -Wextra program.c -o program

Zgłosi każdą z czterech linii powyżej już podczas kompilacji. To najcenniejsze ostrzeżenie w C i w edytorze powyżej jest domyślnie włączone.

O praktycznej stronie korzystania z nich, czyli wyrównanych tabelach, czytelnym wypisywaniu liczb zmiennoprzecinkowych i wczytywaniu danych bez klasycznego błędu ze znakiem nowej linii, przeczytasz na stronach printf i scanf.