• Doku
  • ASCII-EBCDIC
  • Netzwerk
  • Kabel
  • EAN
  • ISO Normen
  • C++
   • gcc howto
   • printf
   • unix Time
   • make
  • Wertpapiere
• HowTo
• Australien
• Links
• Impressum

Strings mit printf formatieren

Print Formate
Print Funktionen
Umwandlungs Spezifikationen
Beispiele

Es gibt viele Funktionen in C/C++ mit deren Hilfe wir Daten von der internen Representation in ein für Menschen lesbares format umwandeln können.
Diese Funktionen müssen natürlich wissen WIE wie wir diese Werte dargestellt haben wollen, und das Teilen wir ihnen im sog. Format-String mit. (z.B: "%.*s:)
daher die Bezeichnung formatierte Ausgabe.
Dieser String sieht kompliziert aus (ist es manchmal auch) aber man Gewöhnt sich ziemlich schnell daran.

Hinweis In C++ Programmen sollte man falls möglich die stream-funktionen verwenden (typensicher), da ein falsches Argument in der print-funktionen leicht das gesammte Programm zum Absturz bringen kann.

Die Print-Funktionen können wir in zwei Kategorien unterteilen:

Die Byte-Print-Funktionen (deklariert in <stdio.h>)
Diese konvertieren die interne Representation in einen C-String (char x[xxx];):
fprint, printf, sprintf, vfprintf, vprintf und vsprintf.

Die Wide-Print-Functionen (deklariert in <wchar.h>
Diese konvertieren die interne Representation in einen Wide-String (wchar_t):
fwprintf, swprintf, wprintf, vfwprintf, vswprintf und vwprintf.

Print Formate:

Ein Format-String hat die gleiche Syntax fü beide Arten von Print-Funktionen.
(Gott sei Dank!!)

Ein Format String besteht aus keinem oder mehreren Umwandlungs Spezifikationen die in einem ganz normalen Text eingebettet sein können.

Die Print funktionen durchsuchen den Format-String von vorne nach hinten um herauszufinden was für Umwandlungen gemacht werden müssen.
Jede Print-Funktion akzeptiert eine variierende Anzahl von Argumenten (siehe auch va_list).
Diese Argumente werden dann der Reihe nach angearbeitet.
Überzählige Argumente werden ignoriert, zuwenige Argumente aber führen zu nicht vorhersehbaren Ergebnissen (Abstürzen)

Print Funktionen

Die Format-Strings können ganz normalen Text oder White-Spaces neben Umwandlungs Spezifikationen beinhalten.
Normale Zeichen werden von den Print-Funktionen einfach Ausgegeben, Umwandlungs Spezifikationen jedoch werden durch die entprechend Umgewandelten Werte ersetzt.
Eine Umwandlungs Spezifikationen hat das folgende Format:

Bold bedeutet neue features die mit C99 einführt wurden.

Alle Umwandlungs Spezifikationen fangen mit einem Prozent Zeichen (%) an.
Danach können keine oder mehrere Format flags folgen:

• - -- linksbündige Darstellung
• + -- um ein Plus Zeichen bei allen positiven Integer-Werten Darzustellen
• space -- um eine Leerzeichen space für alle vorzeichenbehafteten Integer-Werten Darzustellen die weder Positiv noch negativ sind (ergo null)
• # -- um ein 0 Voranzustellen (bei einer o Konversation), um ein 0x Voranzustellen (bei einer x Konversation), um ein 0X Voranzustellen (bei einer X Konversation), oder um einen Dezimalpunkt oder eine Fraktion Darzustellen, die sonst bei einer Floating-Point Konversation unterdrückt würden
• 0 -- um das Ergebnis mit führenden Nullen aufzufüllen. (nach einen evtl auszugebenden vorzeichen)

Den Format-Flags können Feld-Längen Bezeichner folgen, welche die mimimale Anzahl an Zeichen beschreiben, die ausgegeben werden sollen.
Solange nichts anderes angegeben ist, wird versucht das Ergebnis links mit Leerzeichen aufzufüllen.
Wird ein asterisk (*) anstelle einer Zahl im Formatstring abgegeben, nimmt die Print-Funktion das nächse Argument, das von Typ int) sein muss, und verwendet es als Länge-Bezeichner des Feldes.
Falls die länge negativ ist wird ein minus als Vorzeichen unterdrückt.

Danach kann ein Punkt (.) gefolgt von einer Zahl, die die Genauigkeit angibt folgen. Diese Zahl hat mehrere Bedeutungen:

• Interger -- Die minimale Anzahl an Stellen die Erzeugt werden soll
• floats -- Die Anzahl der Fraktions-Zeichen bei einer Umwandlung mit e,E, oder f
• floats -- Die Anzahl der signifikanten Zeichen bei einer Umwandlung mit g or G
• c-strings -- Die maximale Anzahl von Zeichen die von einem String ausgegeben werden sollen (s)

Die Genauigkeit kann auch durch einen asterisk (*) ersetzt werde. Dabei wird das nächste Argument (integer-wert) als präzision verwendet.

Umwandlungs Spezifikationen

Nun folgen die Umwandlungs Spezifizierer. Je nach Spezifizierer werden verschieden Typen als Argument erwartet, und, falls keine erweiterten Formatierungen (Feldlänge, Präzision;) angegeben wurden, werden die in der Tabelle angegebenen Default-Werte verwendet:

Konversions   Argument       Konvertierter        Default  Prä-
Spezifizierer    Typ             Wert              Base  zision

   %a         double x       (double)x              10     6  added with C99
  %La         long double x  (long double)x         10     6  added with C99
   %A         double x       (double)x              10     6  added with C99
  %LA         long double x  (long double)x         10     6  added with C99

   %c         int x          (unsigned char)x
  %lc         wint_t x       wchar_t a[2] = {x}

   %d         int x          (int)x                 10     1
  %hd         int x          (short)x               10     1
  %ld         long x         (long)x                10     1
  %hhd        int x          (signed char)x         10     1  added with C99
  %jd         intmax_t x     (intmax_t)x            10     1  added with C99
  %lld        long long x    (long long)x           10     1  added with C99
  %td         ptrdiff_t x    (ptrdiff_t)x           10     1  added with C99
  %zd         size_t x       (ptrdiff_t)x           10     1  added with C99
 
   %e         double x       (double)x              10     6
  %Le         long double x  (long double)x         10     6
   %E         double x       (double)x              10     6
  %LE         long double x  (long double)x         10     6

   %f         double x       (double)x              10     6
  %Lf         long double x  (long double)x         10     6
   %F         double x       (double)x              10     6  added with C99
  %LF         long double x  (long double)x         10     6  added with C99

   %g         double x       (double)x              10     6
  %Lg         long double x  (long double)x         10     6
   %G         double x       (double)x              10     6
  %LG         long double x  (long double)x         10     6

   %i         int x          (int)x                 10     1
  %hi         int x          (short)x               10     1
  %li         long x         (long)x                10     1
  %hhi        int x          (signed char)x         10     1  added with C99
  %ji         intmax_t x     (intmax_t)x            10     1  added with C99
  %lli        long long x    (long long)x           10     1  added with C99
  %ti         ptrdiff_t x    (ptrdiff_t)x           10     1  added with C99
  %zi         size_t x       (ptrdiff_t)x           10     1  added with C99

   %n         int *x
  %hn         short *x
  %ln         long *x
  %hhn        int *x                                          added with C99
  %jn         intmax_t *x                                     added with C99
  %lln        long long *x                                    added with C99
  %tn         ptrdiff_t *x                                    added with C99
  %zn         size_t *x                                       added with C99

   %o         int x          (unsigned int)x         8     1
  %ho         int x          (unsigned short)x       8     1
  %lo         long x         (unsigned long)x        8     1
  %hho        int x          (unsigned char)x        8     1  added with C99
  %jo         intmax_t x     (uintmax_t)x            8     1  added with C99
  %llo        long long x    (unsigned long long)x   8     1  added with C99
  %to         ptrdiff_t x    (size_t)x               8     1  added with C99
  %zo         size_t x       (size_t)x               8     1  added with C99

   %p         void *x        (void *)x

   %s         char x[]       x[0]...                     large
  %ls         wchar_t x[]    x[0]...                     large

   %u         int x          (unsigned int)x        10     1
  %hu         int x          (unsigned short)x      10     1
  %lu         long x         (unsigned long)x       10     1
  %hhu        int x          (unsigned char)x        8     1  added with C99
  %ju         intmax_t x     (uintmax_t)x            8     1  added with C99
  %llu        long long x    (unsigned long long)x   8     1  added with C99
  %tu         ptrdiff_t x    (size_t)x               8     1  added with C99
  %zu         size_t x       (size_t)x               8     1  added with C99

   %x         int x          (unsigned int)x        16     1
  %hx         int x          (unsigned short)x      16     1
  %lx         long x         (unsigned long)x       16     1
  %hhx        int x          (unsigned char)x        8     1  added with C99
  %jx         intmax_t x     (uintmax_t)x            8     1  added with C99
  %llx        long long x    (unsigned long long)x   8     1  added with C99
  %tx         ptrdiff_t x    (size_t)x               8     1  added with C99
  %zx         size_t x       (size_t)x               8     1  added with C99

   %X         int x          (unsigned int)x        16     1
  %hX         int x          (unsigned short)x      16     1
  %lX         long x         (unsigned long)x       16     1
  %hhX        int x          (unsigned char)x        8     1  added with C99
  %jX         intmax_t x     (uintmax_t)x            8     1  added with C99
  %llX        long long x    (unsigned long long)x   8     1  added with C99
  %tX         ptrdiff_t x    (size_t)x               8     1  added with C99
  %zX         size_t x       (size_t)x               8     1  added with C99

   %%         none           '%'

Es gibt noch einige Sonderfälle die nicht in der obigen Tabelle angegeben sind:

Bei Floating-Point Zahlen (float, double):

• Positive Unendlichkeit wird als inf oder INF ausgegeben.
• Negative Unendlichkeit wird als -inf oder -INF ausgegeben.
• Not-a-number (NaN) wird als nan oder NAN ausgegeben.

Die Großschrift-Variante der Umwandlungs Spezifizierer gibt normalerweise auch nur Großschrift aus.

Beispiele

%c (Single Character).

    printf("%c", 'a')               generates a
    printf("<%3c|%-3c>", 'a', 'b')  generates <  a|b  >

%c (Wide Character).

    wprintf(L"%c", 'a')             generates btowc(a)
    printf("%lc", L'a')             generates a
    wprintf(L"lc", L'a')            generates L'a'

Wir verwenden %d, %i, %o, %u, %x, oder %X um eine vorzeichenbehaftete ganze Zahl (integer) Darzustellen.
%d oder %i spezifiziert eine vorzeichenbehaftete Dezimale Darstellung, %o eine vorzeichenlose Oktale Darstellung, %u eine vorzeichenlose Dezimale Darstellung, %x eine vorzeichenlose Hexadezimale Darstellung (mit den Zeichen 0-9 und a-f), und %X eine vorzeichenlose Hexadezimale Darstellung (mit den Zeichen 0-9 and A-F).

    printf("%d %o %x", 31, 31, 31)  generates 31 37 1f
    printf("%hu", 0xffff)           generates 65535
    printf("%#X %+d", 31, 31)       generates 0X1F +31

%f oder %F wir verwendet um floating-Point Zahlen (float, double) darzustellen.
Das Ergebnis wird gerundet dargestellt:

    printf("%f", 31.4)              generates 31.400000
    printf("%.0f %#.0f", 31.0, 31.0)generates 31 31.

    printf("%.6g", 31.4)            generates 31.4
    printf("%.1g", 31.4)            generates 3.14e+01

%n wird benötigt, um die Anzahl der bisher generierten Zeichen zu speichern. (Bis zum Punkt an dem sich %n befindet). Das Ergebnis wird in einen integer-Wert geschrieben wessen Adresse das nächst Atgument liefert:

    int x;    
    printf("abc%n", &x)             schreibt 2 in die Variable x
    printf("length [%d]", x)        generates length [3]

%p wird verwendet um einen void Pointer Darzustellen (oder besser die Adresse des Speicherbereiches auf den dieser Pointer zeigt:
(die Umwandlung kann zwischen Compilern und Betriebssystenen variieren).

    printf("%p", (void *)&x)        generates, e.g. F4C0

%s fügt einen C-String ein:

    printf("%s", "hello")           generates hello
    printf("%.2s", "hello")         generates he

    wprintf(L"%s", "hello")         generates hello

    printf("%ls", L"hello")         generates hello
    wprintf(L"%.2s", L"hello")      generates he

Um aber ein simples % zu Erzeugen verwenden wir %%).

    
    printf("%%")                    generates %