Namespaces
Variants

std:: printf, std:: fprintf, std:: sprintf, std:: snprintf

From cppreference.net
< cpp ‎ | io ‎ | c
C++
Input/output library
C-style I/O
Definiert im Header <cstdio>
int printf ( const char * format, ... ) ;
(1)
int fprintf ( std:: FILE * stream, const char * format, ... ) ;
(2)
int sprintf ( char * buffer, const char * format, ... ) ;
(3)
int snprintf ( char * buffer, std:: size_t buf_size, const char * format, ... ) ;
(4) (seit C++11)

Lädt die Daten von den angegebenen Speicherorten, konvertiert sie in entsprechende Zeichenketten und schreibt die Ergebnisse in verschiedene Senken.

1) Schreibt die Ergebnisse in stdout .
2) Schreibt die Ergebnisse in einen Dateistrom stream .
3) Schreibt die Ergebnisse in einen Zeichenstring buffer .
4) Schreibt die Ergebnisse in einen Zeichenstring buffer . Höchstens buf_size - 1 Zeichen werden geschrieben. Der resultierende Zeichenstring wird mit einem Nullzeichen abgeschlossen, es sei denn buf_size ist null. Wenn buf_size null ist, wird nichts geschrieben und buffer kann ein Nullzeiger sein, jedoch wird der Rückgabewert (Anzahl der Bytes, die ohne den Nullterminator geschrieben würden) weiterhin berechnet und zurückgegeben.

Wenn ein Aufruf von sprintf oder snprintf dazu führt, dass das Kopieren zwischen Objekten stattfindet, die sich überlappen, ist das Verhalten undefiniert (z.B. sprintf ( buf, "%s text" , buf ) ; ).

Inhaltsverzeichnis

Parameter

stream - Ausgabedateistream, in den geschrieben wird
buffer - Zeiger auf eine Zeichenkette, in die geschrieben wird
buf_size - bis zu buf_size - 1 Zeichen können geschrieben werden, plus den Nullterminator
format - Zeiger auf eine nullterminierte Multibyte-Zeichenkette, die angibt, wie die Daten zu interpretieren sind
... - Argumente, die die auszugebenden Daten spezifizieren. Wenn ein Argument nach Standardargument-Höherstufung nicht dem erwarteten Typ der entsprechenden Konvertierungsspezifikation entspricht (der erwartete Typ ist der höhergestufte Typ oder ein kompatibler Typ des höhergestuften Typs), oder wenn weniger Argumente vorhanden sind als von format benötigt, ist das Verhalten undefiniert. Wenn mehr Argumente vorhanden sind als von format benötigt, werden die überzähligen Argumente ausgewertet und ignoriert

Die Format -Zeichenkette besteht aus gewöhnlichen Byte-Zeichen (außer % ), die unverändert in den Ausgabestrom kopiert werden, und Konvertierungsspezifikationen. Jede Konvertierungsspezifikation hat folgendes Format:

  • Einleitendes % Zeichen.
  • (optional) ein oder mehrere Flags, die das Verhalten der Konvertierung modifizieren:
  • - : Das Ergebnis der Konvertierung wird innerhalb des Feldes linksbündig ausgerichtet (standardmäßig ist es rechtsbündig).
  • + : Das Vorzeichen von vorzeichenbehafteten Konvertierungen wird immer dem Ergebnis vorangestellt (standardmäßig wird das Ergebnis nur bei negativen Werten mit einem Minus versehen).
  • space : Wenn das Ergebnis einer vorzeichenbehafteten Konvertierung nicht mit einem Vorzeichen beginnt oder leer ist, wird dem Ergebnis ein Leerzeichen vorangestellt. Wird ignoriert, wenn das + -Flag vorhanden ist.
  • # : Die alternative Form der Konvertierung wird durchgeführt. Siehe die nachfolgende Tabelle für genaue Auswirkungen, andernfalls ist das Verhalten undefiniert.
  • 0 : Für Ganzzahl- und Gleitkommazahl-Konvertierungen werden führende Nullen zum Auffüllen des Feldes verwendet anstelle von space -Zeichen. Für Ganzzahlen wird es ignoriert, wenn die Genauigkeit explizit angegeben ist. Für andere Konvertierungen führt die Verwendung dieses Flags zu undefiniertem Verhalten. Wird ignoriert, wenn das - -Flag vorhanden ist.
  • (optional) Ganzzahlwert oder * , der die minimale Feldbreite angibt. Das Ergebnis wird bei Bedarf links (bei rechtsbündiger Ausrichtung) oder rechts (bei linksbündiger Ausrichtung) mit Leerzeichen aufgefüllt (standardmäßig). Falls * verwendet wird, wird die Breite durch ein zusätzliches Argument vom Typ int angegeben, das vor dem zu konvertierenden Argument und dem die Genauigkeit liefernden Argument (falls vorhanden) erscheint. Wenn der Wert des Arguments negativ ist, führt dies zur Angabe des - Flags und einer positiven Feldbreite (Hinweis: Dies ist die minimale Breite: Der Wert wird niemals abgeschnitten.).
  • (optional) . gefolgt von einer Ganzzahl oder * , oder keines von beiden, was die Präzision der Konvertierung spezifiziert. Falls * verwendet wird, wird die Präzision durch ein zusätzliches Argument vom Typ int angegeben, das vor dem zu konvertierenden Argument erscheint, aber nach dem Argument, das die minimale Feldbreite angibt, falls eines angegeben wurde. Wenn der Wert dieses Arguments negativ ist, wird er ignoriert. Wenn weder eine Zahl noch * verwendet wird, wird die Präzision als Null angenommen. Siehe die nachfolgende Tabelle für die genauen Auswirkungen der Präzision .
  • (optional) Längenmodifikator der die Größe des Arguments spezifiziert (in Kombination mit dem Konvertierungsformat-Spezifizierer spezifiziert er den Typ des entsprechenden Arguments).
  • Konvertierungsformat-Spezifizierer.

Die folgenden Formatbezeichner sind verfügbar:

Konvertierung
Spezifizierer 		Erklärung Erwarteter
Argumenttyp
Längenmodifikator→ hh h keine l ll j z t L
Nur verfügbar seit C++11→ Ja Ja Ja Ja Ja
% Schreibt ein literales % . Die vollständige Konvertierungsspezifikation muss %% lauten. N/A N/A N/A N/A N/A N/A N/A N/A N/A
c

Schreibt ein einzelnes Zeichen .

  • Das Argument wird zuerst in unsigned char konvertiert.
  • Wenn der l -Modifikator verwendet wird, wird das Argument zuerst in eine Zeichenkette konvertiert, als ob durch %ls mit einem wchar_t [ 2 ] -Argument.
N/A N/A
int
std::wint_t
N/A N/A N/A N/A N/A
s

Schreibt einen Zeichenstring .

  • Das Argument muss ein Zeiger auf das erste Element eines Zeichenarrays sein.
  • Precision spezifiziert die maximale Anzahl an zu schreibenden Bytes. Wenn Precision nicht angegeben ist, werden alle Bytes bis zum ersten Nullterminator (ausschließlich) geschrieben.
  • Wenn der l -Spezifizierer verwendet wird, muss das Argument ein Zeiger auf das erste Element eines Arrays von wchar_t sein, welcher in ein char-Array konvertiert wird, wie durch einen Aufruf von std::wcrtomb mit einem null-initialisierten Konvertierungszustand.
N/A N/A
char *
wchar_t *
N/A N/A N/A N/A N/A
d
i

Wandelt eine vorzeichenbehaftete Ganzzahl in die Dezimaldarstellung [-]dddd um.

  • Präzision gibt die minimale Anzahl der anzuzeigenden Ziffern an. Die Standardpräzision ist 1 .
  • Wenn sowohl der konvertierte Wert als auch die Präzision ​ 0 ​ sind, ergibt die Konvertierung keine Zeichen.
  • Für den z -Modifikator ist der erwartete Argumenttyp die vorzeichenbehaftete Version von std::size_t .
signed char
short
int
long
long long
※
N/A
o

Wandelt eine unsigned integer in Oktaldarstellung oooo um.

  • Precision gibt die Mindestanzahl der anzuzeigenden Ziffern an. Die Standard-Präzision ist 1 .
  • Wenn sowohl der konvertierte Wert als auch die Präzision ​ 0 ​ sind, ergibt die Konvertierung keine Zeichen.
  • In der alternative implementation wird die Präzision bei Bedarf erhöht, um eine führende Null zu schreiben. In diesem Fall wird, wenn sowohl der konvertierte Wert als auch die Präzision ​ 0 ​ sind, eine einzelne ​ 0 ​ geschrieben.
unsigned char
unsigned short
unsigned int
unsigned long
unsigned long long
unsigned Version von std::ptrdiff_t
N/A
x
X

Wandelt eine unsigned integer in eine hexadezimale Darstellung hhhh um.

  • Für die x Konvertierung werden die Buchstaben abcdef verwendet.
  • Für die X Konvertierung werden die Buchstaben ABCDEF verwendet.
  • Precision gibt die Mindestanzahl der anzuzeigenden Ziffern an. Die Standard-Präzision ist 1 .
  • Wenn sowohl der konvertierte Wert als auch die Präzision ​ 0 ​ sind, ergibt die Konvertierung keine Zeichen.
  • In der alternativen Implementierung wird 0x oder 0X den Ergebnissen vorangestellt, wenn der konvertierte Wert ungleich Null ist.
N/A
u

Wandelt eine unsigned integer in die Dezimaldarstellung dddd um.

  • Precision gibt die Mindestanzahl der anzuzeigenden Ziffern an.
  • Die Standard-Präzision ist 1 .
  • Wenn sowohl der konvertierte Wert als auch die Präzision ​ 0 ​ sind, ergibt die Konvertierung keine Zeichen.
N/A
f
F (C++11)

Wandelt eine Gleitkommazahl in die Dezimalschreibweise im Format [-]ddd.ddd um.

  • Präzision gibt die exakte Anzahl der Nachkommastellen an.
  • Die Standardpräzision ist 6 .
  • In der alternativen Implementierung wird das Dezimaltrennzeichen auch dann geschrieben, wenn keine Ziffern folgen.
  • Für die Konvertierung von Unendlich und NaN siehe Anmerkungen .
N/A N/A
double
double (C++11)
N/A N/A N/A N/A
long double
e
E

Wandelt eine Gleitkommazahl in die dezimale Exponentenschreibweise um.

  • Für den e -Konvertierungsstil wird [-]d.ddd  e ±dd verwendet.
  • Für den E -Konvertierungsstil wird [-]d.ddd  E ±dd verwendet.
  • Der Exponent enthält mindestens zwei Ziffern, weitere Ziffern werden nur bei Bedarf verwendet.
  • Wenn der Wert ​ 0 ​ ist, ist der Exponent ebenfalls ​ 0 ​ .
  • Präzision gibt die exakte Anzahl der Ziffern nach dem Dezimaltrennzeichen an.
  • Die Standardpräzision ist 6 .
  • In der alternativen Implementierung wird das Dezimaltrennzeichen auch dann geschrieben, wenn keine Ziffern folgen.
  • Für die Konvertierung von Unendlich und NaN siehe Hinweise .
N/A N/A N/A N/A N/A N/A
a
A

(C++11)

Wandelt eine Gleitkommazahl in die hexadezimale Exponentenschreibweise um.

  • Für den a -Konvertierungsstil wird [-]  0x h.hhh  p ±d verwendet.
  • Für den A -Konvertierungsstil wird [-]  0X h.hhh  P ±d verwendet.
  • Die erste hexadezimale Ziffer ist nicht 0 , wenn das Argument ein normalisierter Gleitkommawert ist.
  • Wenn der Wert ​ 0 ​ ist, ist der Exponent ebenfalls ​ 0 ​ .
  • Präzision gibt die exakte Anzahl der Ziffern nach dem hexadezimalen Punktzeichen an.
  • Die Standardpräzision ist ausreichend für die exakte Darstellung des Werts.
  • In der alternativen Implementierung wird das Dezimalpunktzeichen auch dann geschrieben, wenn keine Ziffern folgen.
  • Für die Konvertierung von Unendlich und NaN siehe Hinweise .
N/A N/A N/A N/A N/A N/A
g
G

Wandelt eine Gleitkommazahl in Dezimal- oder Exponentenschreibweise um, abhängig vom Wert und der Genauigkeit .

  • Für den g -Konvertierungsstil wird die Konvertierung mit Stil e oder f durchgeführt.
  • Für den G -Konvertierungsstil wird die Konvertierung mit Stil E oder f (bis C++11) F (seit C++11) durchgeführt.
  • Sei P gleich der Genauigkeit falls ungleich Null, 6 falls die Genauigkeit nicht angegeben ist, oder 1 falls die Genauigkeit ​ 0 ​ ist. Dann, wenn eine Konvertierung mit Stil E einen Exponenten X hätte:
    • Wenn P > X ≥ −4 , erfolgt die Konvertierung mit Stil f oder F (seit C++11) und Genauigkeit P − 1 − X .
    • Andernfalls erfolgt die Konvertierung mit Stil e oder E und Genauigkeit P − 1 .
  • Sofern keine alternative Darstellung angefordert wird, werden nachgestellte Nullen entfernt, ebenso wird das Dezimaltrennzeichen entfernt, wenn kein Nachkommateil verbleibt.
  • Für Konvertierungen von Unendlich und NaN siehe Hinweise .
N/A N/A N/A N/A N/A N/A
n

Gibt die Anzahl der bisher geschriebenen Zeichen durch diesen Funktionsaufruf zurück.

  • Das Ergebnis wird an die durch das Argument gezeigte Adresse geschrieben .
  • Die Spezifikation darf keine Flags , Feldbreite oder Genauigkeit enthalten.
  • Für den z -Modifikator ist der erwartete Argumenttyp S * , wobei S die signierte Version von std:: size_t ist.
signed char *
short *
int *
long *
long long *
※
N/A
p

Schreibt eine implementierungsdefinierte Zeichenfolge, die einen Zeiger definiert.

N/A N/A
void *
N/A N/A N/A N/A N/A N/A
Hinweise

Die Gleitkomma-Konvertierungsfunktionen konvertieren Unendlich zu inf oder infinity . Welches verwendet wird, ist implementierungsdefiniert.

Keine-Zahl wird zu nan oder nan( char_sequence ) konvertiert. Welches verwendet wird, ist implementierungsdefiniert.

Die Konvertierungen F , E , G , A geben stattdessen INF , INFINITY , NAN aus.

Der Konvertierungsspezifizierer zum Ausgeben von char , unsigned char , signed char , short und unsigned short erwartet gepromotete Typen von Default Argument Promotions , aber vor der Ausgabe wird sein Wert zu char , unsigned char , signed char , short und unsigned short konvertiert. Es ist sicher, Werte dieser Typen zu übergeben, aufgrund der Promotion, die beim Aufruf einer variadischen Funktion stattfindet.

Die korrekten Konvertierungsspezifikationen für die festbreiten Zeichentypen ( std::int8_t usw.) sind im Header <cinttypes> definiert (obwohl PRIdMAX , PRIuMAX usw. synonym mit %jd , %ju usw. sind).

Der speicher-schreibende Konvertierungsspezifizierer %n ist ein häufiges Ziel von Sicherheitslücken, bei denen Formatstrings von Benutzereingaben abhängen.

Es gibt einen Sequence Point nach der Aktion jedes Konvertierungsspezifizierers; dies erlaubt das Speichern mehrerer %n -Ergebnisse in derselben Variable oder, als Randfall, das Ausgeben einer Zeichenkette, die durch einen früheren %n innerhalb desselben Aufrufs modifiziert wurde.

Wenn eine Konvertierungsspezifikation ungültig ist, ist das Verhalten undefiniert.

Rückgabewert

1,2) Anzahl der geschriebenen Zeichen bei Erfolg oder ein negativer Wert bei einem Fehler.
3) Anzahl der geschriebenen Zeichen bei Erfolg (ohne das abschließende Nullzeichen) oder ein negativer Wert bei einem Fehler.
4) Anzahl der Zeichen, die für einen ausreichend großen Puffer geschrieben worden wären, wenn erfolgreich (ohne das abschließende Nullzeichen), oder ein negativer Wert, wenn ein Fehler aufgetreten ist. Somit wurde die (nullterminierte) Ausgabe vollständig geschrieben, genau dann wenn der zurückgegebene Wert nichtnegativ und kleiner als buf_size ist.

Hinweise

POSIX spezifiziert , dass errno bei Fehlern gesetzt wird. Es spezifiziert auch zusätzliche Konvertierungsspezifikationen, insbesondere Unterstützung für die Neuanordnung von Argumenten ( n$ unmittelbar nach % zeigt das n te Argument an).

Das Aufrufen von std::snprintf mit einer Null als buf_size und einem Nullzeiger für buffer ist nützlich (wenn der Mehraufwand eines doppelten Aufrufs akzeptabel ist), um die erforderliche Puffergröße zur Aufnahme der Ausgabe zu bestimmen: 

auto fmt = "sqrt(2) = %f";
int sz = std::snprintf(nullptr, 0, fmt, std::sqrt(2));
std::vector<char> buf(sz + 1); // beachten Sie +1 für Null-Terminator
std::sprintf(buf.data(), fmt, std::sqrt(2)); // passt sicher
**Übersetzte Elemente:** - Kommentar "note +1 for null terminator" → "beachten Sie +1 für Null-Terminator" - Kommentar "certain to fit" → "passt sicher" **Nicht übersetzte Elemente:** - HTML-Tags und Attribute - C++ Code innerhalb der ` 
` Tags
- C++ spezifische Begriffe (auto, int, char, std::snprintf, std::sqrt, std::vector, etc.)
- Format-String "sqrt(2) = %f"

Beispiel

Diesen Code ausführen 
#include <cinttypes>
#include <cstdint>
#include <cstdio>
#include <limits>
int main()
{
    const char* s = "Hello";
    std::printf("Strings:\n"); // same as std::puts("Strings:");
    std::printf("\t[%10s]\n", s);
    std::printf("\t[%-10s]\n", s);
    std::printf("\t[%*s]\n", 10, s);
    std::printf("\t[%-10.*s]\n", 4, s);
    std::printf("\t[%-*.*s]\n", 10, 4, s);
    std::printf("Characters:\t%c %%\n", 'A');
    std::printf("Integers:\n");
    std::printf("\tDecimal:    \t%i %d %.6i %i %.0i %+i %i\n",
                                  1, 2,   3, 0,   0,  4,-4);
    std::printf("\tHexadecimal:\t%x %x %X %#x\n",
                                  5,10,10,  6);
    std::printf("\tOctal:      \t%o %#o %#o\n",
                                 10, 10,  4);
    std::printf("Floating point:\n");
    std::printf("\tRounding:\t%f %.0f %.32f\n", 1.5, 1.5, 1.3);
    std::printf("\tPadding:\t%05.2f %.2f %5.2f\n", 1.5, 1.5, 1.5);
    std::printf("\tScientific:\t%E %e\n", 1.5, 1.5);
    std::printf("\tHexadecimal:\t%a %A\n", 1.5, 1.5);
    std::printf("\tSpecial values:\t0/0=%g 1/0=%g\n", 0.0/0.0, 1.0/0.0);
    std::printf("Variable width control:\n");
    std::printf("\tright-justified variable width: '%*c'\n", 5, 'x');
    int r = std::printf("\tleft-justified variable width : '%*c'\n", -5, 'x');
    std::printf("(the last printf printed %d characters)\n", r);
    std::printf("Fixed-width types:\n");
    std::uint32_t val = std::numeric_limits<std::uint32_t>::max();
    std::printf("\tLargest 32-bit value is %" PRIu32 " or %#" PRIx32 "\n",
                                                 val,            val);
}

Mögliche Ausgabe: 

Strings:
	[     Hello]
	[Hello     ]
	[     Hello]
	[Hell      ]
	[Hell      ]
Characters:	A %
Integers:
	Decimal:    	1 2 000003 0  +4 -4
	Hexadecimal:	5 a A 0x6
	Octal:      	12 012 04
Floating point:
	Rounding:	1.500000 2 1.30000000000000004440892098500626
	Padding:	01.50 1.50  1.50
	Scientific:	1.500000E+00 1.500000e+00
	Hexadecimal:	0x1.8p+0 0X1.8P+0
	Special values:	0/0=-nan 1/0=inf
Variable width control:
	right-justified variable width: '    x'
	left-justified variable width : 'x    '
(the last printf printed 41 characters)
Fixed-width types:
	Largest 32-bit value is 4294967295 or 0xffffffff

Siehe auch

gibt formatierten Breitzeichen-Output an stdout , einen Dateistream oder einen Buffer aus
(Funktion)
(C++11)
gibt formatierten Output an stdout , einen Dateistream oder einen Buffer aus
unter Verwendung einer variablen Argumentenliste
(Funktion)
schreibt einen Zeichenstring in einen Dateistream
(Funktion)
liest formatierten Input von stdin , einem Dateistream oder einem Buffer
(Funktion)
(C++17)
konvertiert einen Integer- oder Fließkommawert in eine Zeichensequenz
(Funktion)
(C++23)
gibt an stdout oder einen Dateistream unter Verwendung einer formatierten Darstellung der Argumente aus
(Funktions-Template)
(C++23)
identisch zu std::print , außer dass jede Ausgabe durch eine zusätzliche neue Zeile abgeschlossen wird
(Funktions-Template)
C-Dokumentation für printf , fprintf , sprintf , snprintf