Formatangaben in C: die vollständige printf- und scanf-Referenz

Eine Formatangabe sagt printf, wie ein Wert zu Text wird, und scanf, wie Text zu einem Wert wird. Es ist der eine Teil von C, in dem der Compiler dir standardmäßig nicht helfen kann - die Argumenttypen sind für die Funktion unsichtbar -, diese Seite ist also die Tabelle zum Nachschlagen.

Die allgemeine Form einer Angabe ist:

%[Flags][Breite][.Genauigkeit][Länge]Umwandlung

Nur das % und der Umwandlungsbuchstabe sind erforderlich. %-8.2lf benutzt alle fünf Teile.

Die Umwandlungstabelle

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

Zwei Einträge verdienen eine Warnung. %n schreibt in den Speicher, statt auszugeben, und ist der Mechanismus hinter der Formatzeichenketten-Schwachstelle - lass niemals Benutzertext in eine Formatzeichenkette gelangen. Und %p verlangt ein void *; ein int * direkt zu übergeben ist undefiniert, auch wenn jeder reale Compiler die Adresse trotzdem ausgibt.

Längenmodifikatoren

Der Längenmodifikator steht zwischen der Genauigkeit und dem Umwandlungsbuchstaben und sagt, wie groß das Argument tatsächlich ist.

Vorzeichenbehaftete Umwandlungen (d i) und vorzeichenlose (u x o) nehmen unterschiedliche Typen - %lu will ein unsigned long, kein long, und das falsch zu machen ist undefiniertes Verhalten, kein kosmetischer Schnitzer.

Und für die Gleitkomma- und Zeichenfamilien:

Die Kombinationen, die du tatsächlich tippst:

#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("hallo");
    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 ist die Angabe, die man sich merken sollte. sizeof, strlen und jede Größe aus der Standardbibliothek liefern size_t, das auf einem 64-Bit-System 8 Bytes hat, während int 4 hat. printf("%d", strlen(s)) ist ein echter Bug, der auf manchen Plattformen zu funktionieren scheint - nimm %zu.

Die Modifikatoren hh und h existieren hauptsächlich für scanf, wo die Größe des Ziels zählt. In printf wird ein short vor dem Aufruf zu int befördert, %d würde es also ohnehin korrekt ausgeben; %hd dokumentiert lediglich die Absicht.

Typen fester Breite

Für <stdint.h>-Typen wie int32_t sind die portablen Angaben Makros aus <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 expandiert zu den für deine Plattform richtigen Buchstaben, und benachbarte Zeichenkettenliterale werden aneinandergehängt, weshalb das Format in drei Teile zerfällt. Es ist hässlich; die Alternative - nach long long casten und %lld benutzen - ist oft lesbarer und immer korrekt.

Flags

Flags stehen unmittelbar hinter dem % und ändern die Darstellung. Sie gelten nur für 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;
}

Flags lassen sich kombinieren: %-+8.2f bedeutet Mindestbreite 8, zwei Nachkommastellen, immer mit Vorzeichen, hinter der Zahl aufgefüllt. - schlägt 0, wenn du beide schreibst.

Breite und Genauigkeit

Breite ist eine Mindestfeldgröße - die Ausgabe wird aufgefüllt, um sie zu erreichen, und nie abgeschnitten, um hineinzupassen. Genauigkeit (hinter einem Punkt) bedeutet für jede Familie etwas anderes:

#include <stdio.h>

int main(void) {
    printf("|%10.3f|\n", 3.14159);     /* Breite 10, 3 Nachkommastellen */
    printf("|%.5d|\n",   42);          /* mindestens 5 Ziffern          */
    printf("|%.3s|\n",   "abcdefg");   /* hoechstens 3 Zeichen          */
    printf("|%.0f|\n",   2.71828);     /* keine Nachkommastellen        */
    printf("|%*d|\n",    8, 42);       /* Breite aus einem Argument     */
    printf("|%.*f|\n",   3, 3.14159);  /* Genauigkeit aus einem Argument */
    return 0;
}

Ein * anstelle einer der Zahlen holt sie aus einem int-Argument, das vor dem Wert selbst gelesen wird. So baust du Tabellen, deren Spaltenbreiten zur Laufzeit berechnet werden.

In scanf hat die Breite eine andere und viel wichtigere Aufgabe: Sie begrenzt, wie viel Eingabe eine Umwandlung verbraucht, und das ist das Einzige, was zwischen %s und einem Pufferüberlauf steht.

Wo printf und scanf sich unterscheiden

Sie sehen gleich aus und widersprechen sich an vier Stellen. Jede davon ist eine aktive Fehlerquelle:

#include <stdio.h>

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

    printf("Gib eine Dezimalzahl und ein Wort ein: ");
    if (scanf("%lf %15s", &d, word) == 2) {   /* %lf und eine Breite */
        printf("%.3f und \"%s\"\n", d, word); /* %f und eine Genauigkeit */
    } else {
        printf("Die Eingabe passte nicht.\n");
    }
    return 0;
}

Probiere 2.5 hallo. Das Format, das sie liest, und das Format, das sie ausgibt, benutzen für dasselbe double verschiedene Buchstaben, und die 15 in %15s deckelt die Eingabe auf 15 Zeichen plus Terminator - genau die Größe von word.

Die scanf-Zeichenmenge

%[...] liest eine Menge von Zeichen statt eines durch Leerraum begrenzten Wortes. Es ist die Art, mit scanf eine ganze Zeile zu lesen, wobei fgets das bessere Werkzeug bleibt:

#include <stdio.h>

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

    printf("Tippe einen Satz: ");
    if (scanf("%63[^\n]", line) == 1) {     /* alles bis zu einem Zeilenumbruch */
        printf("Du hast getippt: %s\n", line);
    }
    return 0;
}

[^\n] bedeutet „alle Zeichen außer einem Zeilenumbruch". %[0-9] würde nur Ziffern lesen, %[abc] nur diese drei Buchstaben. Anders als %s überspringt eine Zeichenmenge keinen führenden Leerraum, ein verirrter Zeilenumbruch im Puffer lässt sie also überhaupt nichts treffen.

Es falsch zu machen ist undefiniertes Verhalten

printf kann den wirklichen Typ deines Arguments nicht sehen. Es liest so viele Bytes, wie die Angabe impliziert, gedeutet so, wie die Angabe es sagt. Eine Fehlpaarung ist also kein Formatierungsschluckauf - es ist das Lesen von Speicher als das Falsche:

printf("%d\n", 3.5);        /* gibt Müll aus: liest die Bits eines double als int */
printf("%s\n", 42);         /* behandelt 42 als Adresse - Absturz */
printf("%d\n", strlen(s));  /* size_t als int gelesen - auf 64 Bit falsch */
printf("%f\n", 3);          /* int als double gelesen - Müll */

Die Verteidigung kostet ein Flag. Kompiliere mit -Wall, und GCC prüft jede wörtliche Formatzeichenkette gegen ihre Argumente:

gcc -Wall -Wextra program.c -o program

Es meldet jede der vier obigen Zeilen zur Übersetzungszeit. Das ist die wertvollste Warnung in C, und im Editor oben ist sie standardmäßig an.

Für die praktische Seite - ausgerichtete Tabellen, Gleitkommazahlen lesbar ausgeben, Eingaben ohne den klassischen Zeilenumbruch-Bug lesen - siehe printf und scanf.