Dokumentacja C z przykładami: printf

Q: Jak działa printf w C?

printf przyjmuje łańcuch formatujący i przegląda go znak po znaku. Zwykłe znaki wypisuje bez zmian, a każdy % rozpoczyna specyfikację konwersji, która pobiera jeden z kolejnych argumentów i wypisuje go w żądanej postaci. printf("%d apples\n", 5) wypisuje 5 apples i znak nowej linii.

Q: Jak wypisać liczbę float z 2 miejscami po przecinku w C?

Użyj precyzji: printf("%.2f\n", 3.14159) wypisuje 3.14. Liczba po kropce określa, ile cyfr ma się pojawić po przecinku dziesiętnym. %f bez precyzji zawsze wypisuje 6 cyfr i dlatego niesformatowane liczby zmiennoprzecinkowe wyglądają tak chaotycznie.

Q: Dlaczego printf(user_input) jest niebezpieczne?

Jeśli tekst użytkownika zawiera sekwencje %, printf je wykona i odczyta argumenty, których nigdy nie przekazano. To wycieka pamięć stosu, a z %n pozwala nawet zapisywać do pamięci. To klasyczna podatność format string. Zawsze pisz zamiast tego printf("%s", user_input).

printf to pierwsza funkcja, jakiej uczy się każdy programista C, i zarazem ta, do której dokumentacji większość z nich nigdy porządnie nie zajrzała. Warto poświęcić jej dziesięć minut, bo jej łańcuch formatujący to mały, osobny język, a błędny specyfikator to nie literówka, tylko niezdefiniowane zachowanie.

Funkcja znajduje się w <stdio.h>, więc każdy program, który jej używa, zaczyna się od #include <stdio.h>.

Model łańcucha formatującego

printf przechodzi przez łańcuch formatujący znak po znaku. Wszystko, co nie jest %, wypisuje dokładnie tak, jak jest zapisane. Znak % rozpoczyna specyfikację konwersji, która pobiera kolejny argument i wypisuje go w żądanej postaci.

#include <stdio.h>

int main(void) {
    int    count = 5;
    double price = 2.5;
    char   grade = 'A';
    const char *name = "jablek";

    printf("Zwykly tekst, bez argumentow.\n");
    printf("%d %s kosztuje $%.2f (klasa %c)\n", count, name, price, grade);
    return 0;
}

Argumenty są dopasowywane do specyfikatorów wyłącznie według pozycji: pierwszy % bierze count, drugi name i tak dalej. printf nie ma jak sprawdzić, czy przekazujesz to, co obiecujesz, bo nie widzi typów, więc łańcuch formatujący to umowa, której musisz dotrzymać. Właśnie dlatego warto włączyć -Wall: GCC czyta literał formatujący w czasie kompilacji i ostrzega, gdy argument nie pasuje.

Nic nie wymusza nowej linii. printf("Hello") zostawia kursor za o, i dlatego prawie każdy łańcuch formatujący kończy się na \n.

Specyfikatory używane na co dzień

Pięć z nich pokrywa większość kodu:

Specyfikator	Wypisuje	Przykładowe wywołanie	Wynik
`%d`	`int` ze znakiem	`printf("%d", -42)`	`-42`
`%f`	`double`	`printf("%f", 2.5)`	`2.500000`
`%s`	łańcuch znaków (`char *`)	`printf("%s", "hi")`	`hi`
`%c`	pojedynczy znak	`printf("%c", 'A')`	`A`
`%p`	adres wskaźnika	`printf("%p", (void*)&x)`	`0x7ffd...`

#include <stdio.h>

int main(void) {
    int x = 42;

    printf("int      : %d\n", x);
    printf("double   : %f\n", 2.5);
    printf("lancuch  : %s\n", "czesc");
    printf("znak     : %c\n", 'A');
    printf("wskaznik : %p\n", (void *)&x);
    printf("procent  : 100%%\n");
    return 0;
}

W tym fragmencie kryją się dwie zasady. Dosłowny % zapisuje się jako %%, a samotny % na końcu łańcucha formatującego to niezdefiniowane zachowanie. Z kolei %p wymaga void *, więc rzutuj wskaźnik: przekazanie int * wprost jest formalnie niezdefiniowane, nawet jeśli w praktyce wypisuje się dobrze.

Pełna tabela, ze wszystkimi specyfikatorami, modyfikatorami długości i kolumną dla scanf, jest na stronie o specyfikatorach formatu. Ta strona trzyma się tych, po które sięgasz najczęściej.

Szerokość, precyzja i wyrównanie

Między % a literą możesz wstawić flagi, szerokość i precyzję. Tak zamienia się pętlę w tabelę.

#include <stdio.h>

int main(void) {
    printf("|%5d|\n", 42);        /* szerokosc 5, wypelnienie przed wartoscia */
    printf("|%-5d|\n", 42);       /* flaga minus: wypelnienie za wartoscia    */
    printf("|%05d|\n", 42);       /* flaga zero: wypelnienie zerami           */
    printf("|%+d|\n", 42);        /* flaga plus: zawsze pokazuj znak          */
    printf("|%8.2f|\n", 3.14159); /* szerokosc 8, 2 cyfry po kropce           */
    printf("|%-10s|\n", "ok");    /* lancuchy tez sa wypelniane               */
    printf("|%.3s|\n", "przytnij mnie");  /* precyzja dla lancucha go przycina */
    return 0;
}

Szerokość to minimum, nigdy maksimum: %3d z wartością 123456 wypisze wszystkie sześć cyfr. Precyzja znaczy co innego dla każdego typu: liczbę cyfr po przecinku dla %f, maksymalną liczbę znaków dla %s i minimalną liczbę cyfr dla %d.

Obie można podać w czasie działania programu za pomocą *, które odczytuje argument typu int:

#include <stdio.h>

int main(void) {
    const char *names[] = {"Ada", "Grace", "Alan"};
    double scores[] = {92.5, 105.25, 87.0};
    int width = 10;

    printf("%-*s %8s\n", width, "IMIE", "WYNIK");
    for (int i = 0; i < 3; i++) {
        printf("%-*s %8.2f\n", width, names[i], scores[i]);
    }
    return 0;
}

Zmiana width przebudowuje całą tabelę. To standardowy sposób na wyrównane kolumny w C, bez żadnej pomocniczej funkcji do dopełniania napisów.

Rozsądne wypisywanie liczb zmiennoprzecinkowych

%f bez precyzji zawsze wypisuje sześć cyfr po kropce, a rzadko ktoś tego chce:

#include <stdio.h>

int main(void) {
    double value = 1234.5;
    double tiny  = 0.000012345;
    double huge  = 123456789012.0;

    printf("%%f    : %f\n", value);
    printf("%%.2f  : %.2f\n", value);
    printf("%%.0f  : %.0f\n", value);
    printf("%%e    : %e\n", tiny);
    printf("%%g    : %g\n", tiny);
    printf("%%g    : %g\n", huge);
    printf("%%g    : %g\n", value);
    return 0;
}

Trzy opcje i praktyczna zasada dla każdej:

%.Nf dla pieniędzy, pomiarów i wszystkiego, co ma naturalną liczbę miejsc po przecinku. %.2f to właściwy wybór dla kwot.
%e dla notacji naukowej, zawsze w postaci d.dddddde±dd.
%g, gdy nie znasz z góry rzędu wielkości. Wybiera krótszą z form %f i %e oraz usuwa końcowe zera, więc to najrozsądniejszy domyślny wybór przy logowaniu wartości, której jeszcze nie znasz.

Jedną pułapkę warto powiedzieć wprost: w printf nie ma %lf. Argumenty typu float są promowane do double, zanim printf je zobaczy, więc %f obsługuje oba typy, a %lf ma znaczenie tylko w scanf, gdzie liczy się rozmiar miejsca docelowego. (C99 akceptuje %lf w printf jako synonim, ale nawyk pisania go prowadzi do wpisywania %f w scanf, a to już naprawdę się psuje.)

Liczby całkowite innych rozmiarów

%d jest dla int. Większe typy lub typy bez znaku wymagają modyfikatora długości, a ich pomylenie to niezdefiniowane zachowanie, a nie błąd zaokrąglenia:

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

int main(void) {
    long           big  = 3000000000L;
    unsigned int   u    = 4000000000u;
    size_t         len  = sizeof "hello";
    uint64_t       id   = 1234567890123456789ULL;

    printf("long     : %ld\n", big);
    printf("unsigned : %u\n", u);
    printf("size_t   : %zu\n", len);
    printf("uint64_t : %llu\n", (unsigned long long)id);

    printf("hex      : %x  HEX: %X  octal: %o\n", 255, 255, 8);
    return 0;
}

%zu dla size_t to ten, który ludzie najczęściej mylą. sizeof zwraca size_t, a nie int, więc printf("%d", sizeof x) to błąd, który przypadkiem działa na systemach 32-bitowych, a na 64-bitowych zachowuje się źle.

Wartość zwracana

printf zwraca liczbę wypisanych znaków albo liczbę ujemną w razie błędu. Zwykle się ją ignoruje i przeważnie nie ma w tym nic złego, ale bywa naprawdę przydatna, gdy musisz wiedzieć, jak szeroki był wynik:

#include <stdio.h>

int main(void) {
    int written = printf("Witaj, swiecie!\n");
    printf("to wywolanie wypisalo %d znakow\n", written);

    /* Przydatne do podkreslenia czegos, czego szerokosci nie znasz: */
    const char *title = "Raport";
    int n = printf("%s\n", title) - 1;   /* minus znak nowej linii */
    for (int i = 0; i < n; i++) {
        putchar('=');
    }
    putchar('\n');
    return 0;
}

Pokrewne sprintf i snprintf zapisują do bufora zamiast na ekran i zwracają długość wygenerowanego tekstu. Zawsze wybieraj snprintf, które przyjmuje rozmiar bufora i nie może go przepełnić:

#include <stdio.h>

int main(void) {
    char buffer[32];
    int n = snprintf(buffer, sizeof buffer, "%s zdobyla %.1f pkt", "Ada", 92.5);

    printf("[%s] (potrzeba bylo %d znakow)\n", buffer, n);
    return 0;
}

snprintf zwraca długość, jakiej potrzebowałby pełny łańcuch, więc wartość zwracana równa rozmiarowi bufora lub większa oznacza, że wynik został obcięty.

Podatność format string

To jedyny problem bezpieczeństwa w printf, ale poważny. Nigdy nie przekazuj jako łańcucha formatującego danych, które nie pochodzą od ciebie:

/* NIEBEZPIECZNE: nigdy tego nie rob */
printf(user_input);

/* Poprawnie */
printf("%s", user_input);

Jeśli user_input zawiera %s, printf odczyta argument, którego nigdy nie przekazano, i podąży za śmieciami, które wyglądają jak wskaźnik, zwykle kończąc awarią. Powtórzone %x zrzuca zawartość stosu na ekran, a mogą tam być hasła lub klucze. Natomiast %n, które zapisuje liczbę znaków do argumentu, historycznie zamieniało ten błąd w dowolne uszkodzenie pamięci i zdalne wykonanie kodu.

Zasada jest bezwzględna i nic nie kosztuje: łańcuch formatujący to zawsze literał napisany przez ciebie. Wszystko, co zmienne, trafia do argumentów. Opcja GCC -Wformat-security wyłapuje ten błąd i jest zawarta w -Wall -Wextra.

Buforowanie: dlaczego wynik czasem pojawia się z opóźnieniem

printf nie pisze od razu do terminala. Wyjście jest buforowane: opróżniane, gdy bufor się zapełni, gdy w terminalu pojawi się znak nowej linii albo gdy program zakończy się normalnie. Wynikają z tego dwie rzeczy:

Program, który się wysypie, może zgubić tekst, który „już został wypisany”. Jeśli debugujesz za pomocą printf i ostatni komunikat się nie pojawia, awaria nastąpiła po tej linii, a nie przed nią. Dodaj fflush(stdout) albo wysyłaj komunikaty debugowania na stderr, który nie jest buforowany.
fprintf(stderr, ...) to właściwy sposób wypisywania błędów. Nie jest buforowany i trafia do osobnego strumienia, który użytkownicy mogą przekierować niezależnie od zwykłego wyjścia.

#include <stdio.h>

int main(void) {
    printf("zwykle wyjscie trafia na stdout\n");
    fprintf(stderr, "bledy trafiaja na stderr\n");
    fflush(stdout);
    return 0;
}

Najczęściej zadawane pytania

Jak działa printf w C?

printf przyjmuje łańcuch formatujący i przegląda go znak po znaku. Zwykłe znaki wypisuje bez zmian, a każdy % rozpoczyna specyfikację konwersji, która pobiera jeden z kolejnych argumentów i wypisuje go w żądanej postaci. printf("%d apples\n", 5) wypisuje 5 apples i znak nowej linii.

Jak wypisać liczbę float z 2 miejscami po przecinku w C?

Użyj precyzji: printf("%.2f\n", 3.14159) wypisuje 3.14. Liczba po kropce określa, ile cyfr ma się pojawić po przecinku dziesiętnym. %f bez precyzji zawsze wypisuje 6 cyfr i dlatego niesformatowane liczby zmiennoprzecinkowe wyglądają tak chaotycznie.

Dlaczego printf wypisuje śmieci albo program się wysypuje?

Prawie zawsze chodzi o niezgodność specyfikatora z argumentem. printf("%d", 3.5) albo printf("%s", 42) to niezdefiniowane zachowanie: printf nie widzi prawdziwych typów, ufa łańcuchowi formatującemu. Kompiluj z -Wall, wtedy GCC sprawdza format względem argumentów.

Dlaczego printf(user_input) jest niebezpieczne?

Jeśli tekst użytkownika zawiera sekwencje %, printf je wykona i odczyta argumenty, których nigdy nie przekazano. To wycieka pamięć stosu, a z %n pozwala nawet zapisywać do pamięci. To klasyczna podatność format string. Zawsze pisz zamiast tego printf("%s", user_input).

Powiązane zagadnienia