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

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Ein-/Ausgabe-Bibliothek

I/O-Manipulatoren

Print-Funktionen (C++23)

C-Style I/O

Puffer

basic_streambuf

basic_filebuf

basic_stringbuf

basic_spanbuf (C++23)

strstreambuf (C++98/26*)

basic_syncbuf (C++20)

Streams

Abstraktionen

ios_base

basic_ios

basic_istream

basic_ostream

basic_iostream

Datei-I/O

basic_ifstream

basic_ofstream

basic_fstream

String-I/O

basic_istringstream

basic_ostringstream

basic_stringstream

Array-I/O

basic_ispanstream (C++23)

basic_ospanstream (C++23)

basic_spanstream (C++23)

istrstream (C++98/26*)

ostrstream (C++98/26*)

strstream (C++98/26*)

Synchronisierte Ausgabe

basic_osyncstream (C++20)

Typen

streamoff

streamsize

fpos

Fehlerkategorie-Schnittstelle

iostream_category (C++11)

io_errc (C++11)

 

C-Style I/O

Typen und Objekte
FILE fpos_t	stdinstdoutstderr
Funktionen
Datei-Zugriff fopen freopen fclose fflush fwide setbuf setvbuf Direkte Ein-/Ausgabe fread fwrite Unformatierte Ein-/Ausgabe fgetcgetc fgets fputcputc fputs getchar gets (bis C++14) putchar puts ungetc fgetwcgetwc fgetws fputwcputwc fputws getwchar putwchar ungetwc Formatierte Eingabe scanffscanfsscanf vscanfvfscanfvsscanf (C++11)(C++11)(C++11)     wscanffwscanfswscanf vwscanfvfwscanfvswscanf (C++11)(C++11)(C++11)	Formatierte Ausgabe printffprintfsprintfsnprintf (C++11) vprintfvfprintfvsprintfvsnprintf (C++11)     wprintffwprintfswprintf vwprintfvfwprintfvswprintf Dateipositionierung ftell fgetpos fseek fsetpos rewind Fehlerbehandlung clearerr feof ferror perror Operationen auf Dateien remove rename tmpfile tmpnam

 

Definiert in 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 gegebenen Orten, konvertiert sie in Zeichenketten-Äquivalente und schreibt die Ergebnisse in eine Vielzahl von Senken.

1) Schreibt die Ergebnisse nach stdout.

2) Schreibt die Ergebnisse in einen Dateistrom stream.

3) Schreibt die Ergebnisse in eine Zeichenkette buffer.

4) Schreibt die Ergebnisse in eine Zeichenkette buffer. Es werden höchstens buf_size - 1 Zeichen geschrieben. Die resultierende Zeichenkette 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 geschrieben würden, ohne den Nullterminator) trotzdem berechnet und zurückgegeben.

Wenn ein Aufruf von sprintf oder snprintf dazu führt, dass Kopieroperationen zwischen überlappenden Objekten stattfinden, ist das Verhalten undefiniert (z.B. sprintf(buf, "%s text", buf);).

Parameter

stream	-	Ausgabestream, in den geschrieben werden soll
buffer	-	Zeiger auf eine Zeichenkette, in die geschrieben werden soll
buf_size	-	bis zu buf_size - 1 Zeichen können geschrieben werden, zuzüglich des Nullterminators
format	-	Zeiger auf eine null-terminierte Multibyte-Zeichenkette, die angibt, wie die Daten interpretiert werden sollen
...	-	Argumente, die die zu druckenden Daten spezifizieren. Wenn ein Argument nach den Standard-Argument-Promotions nicht dem erwarteten Typ für die entsprechende Konversionsspezifikation entspricht (der erwartete Typ ist der promotionierte Typ oder ein kompatibler Typ des promotionierten Typs), oder wenn es weniger Argumente als von format gefordert gibt, ist das Verhalten undefiniert. Wenn es mehr Argumente gibt als von format gefordert, werden die zusätzlichen Argumente ausgewertet und ignoriert.

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

• ein einführendes %-Zeichen.

• (optional) ein oder mehrere Flags, die das Verhalten der Konversion modifizieren

• -: Das Ergebnis der Konversion wird im Feld linksbündig ausgerichtet (standardmäßig rechtsbündig).
• +: Das Vorzeichen von Vorzeichenkonversionen wird immer dem Ergebnis der Konversion vorangestellt (standardmäßig wird dem Ergebnis nur dann ein Minus vorangestellt, wenn es negativ ist).
• Leerzeichen: Wenn das Ergebnis einer Vorzeichenkonversion nicht mit einem Vorzeichen beginnt oder leer ist, wird dem Ergebnis ein Leerzeichen vorangestellt. Es wird ignoriert, wenn das Flag + vorhanden ist.
• #: Eine alternative Form der Konversion wird durchgeführt. Die genauen Effekte sind in der untenstehenden Tabelle aufgeführt, andernfalls ist das Verhalten undefiniert.
• 0: Bei Ganzzahl- und Gleitkommazahlenkonversionen werden die Felder mit Nullen aufgefüllt anstelle von Leerzeichen. Bei Ganzzahlen wird dies ignoriert, wenn die Genauigkeit explizit angegeben ist. Bei anderen Konversionen führt die Verwendung dieses Flags zu undefiniertem Verhalten. Es wird ignoriert, wenn das Flag - vorhanden ist.

• (optional) ein Ganzzahlwert oder *, der die minimale Feldbreite angibt. Das Ergebnis wird, falls erforderlich, mit Leerzeichen aufgefüllt (standardmäßig) links, wenn rechtsbündig, oder rechts, wenn linksbündig. Wenn * verwendet wird, wird die Breite durch ein zusätzliches Argument vom Typ int angegeben, das vor dem zu konvertierenden Argument und dem Präzisionsargument (falls vorhanden) steht. Wenn der Wert des Arguments negativ ist, resultiert dies in der 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 weder noch, das die Genauigkeit der Konversion angibt. Wenn * verwendet wird, wird die Genauigkeit durch ein zusätzliches Argument vom Typ int angegeben, das vor dem zu konvertierenden Argument steht, aber nach dem Argument für die minimale Feldbreite (falls vorhanden). Wenn der Wert dieses Arguments negativ ist, wird es ignoriert. Wenn weder eine Zahl noch * verwendet wird, wird die Genauigkeit als Null angenommen. Die genauen Effekte der Genauigkeit sind in der untenstehenden Tabelle aufgeführt.

• (optional) Ein Längenmodifikator, der die Größe des Arguments angibt (in Kombination mit dem Konversionsformat-Spezifizierer gibt er den Typ des entsprechenden Arguments an).

• Ein Konversionsformat-Spezifizierer.

Die folgenden Format-Spezifizierer sind verfügbar:

Konversion Spezifizierer	Erklärung	Erwartet Argumenttyp
Längenmodifikator →		hh	h	keine	l	ll	j	z	t	L
Nur verfügbar ab C++11 →		Ja				Ja	Ja	Ja	Ja
%	Schreibt ein literales %. Die vollständige Konversionsspezifikation muss %% sein.	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 es mit %ls und einem wchar_t[2]-Argument wäre.	N/A	N/A	int	std::wint_t	N/A	N/A	N/A	N/A	N/A
s	Schreibt eine Zeichenkette. Das Argument muss ein Zeiger auf das erste Element eines Arrays von Zeichen sein. Genauigkeit gibt die maximal zu schreibende Byte-Anzahl an. Wenn Genauigkeit 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, das in ein Zeichenarray konvertiert wird, als ob es durch einen Aufruf von std::wcrtomb mit einer Null-initialisierten Konvertierungszustand wäre.	N/A	N/A	char*	wchar_t*	N/A	N/A	N/A	N/A	N/A
d i	Konvertiert eine vorzeichenbehaftete Ganzzahl in die Dezimaldarstellung [-]dddd. Genauigkeit gibt die minimale Anzahl der anzuzeigenden Ziffern an. Die Standardgenauigkeit ist 1. Wenn sowohl der konvertierte Wert als auch die Genauigkeit ​0​ sind, erzeugt die Konversion 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	std::intmax_t	※	std::ptrdiff_t	N/A
o	Konvertiert eine vorzeichenlose Ganzzahl in die Oktaldarstellung oooo. Genauigkeit gibt die minimale Anzahl der anzuzeigenden Ziffern an. Die Standardgenauigkeit ist 1. Wenn sowohl der konvertierte Wert als auch die Genauigkeit ​0​ sind, erzeugt die Konversion keine Zeichen. In der alternativen Implementierung wird die Genauigkeit bei Bedarf erhöht, um eine führende Null zu schreiben. In diesem Fall wird, wenn sowohl der konvertierte Wert als auch die Genauigkeit ​0​ sind, eine einzelne ​0​ geschrieben.	unsigned char	unsigned short	unsigned int	unsigned long	unsigned long long	std::uintmax_t	std::size_t	vorzeichenlose Version von std::ptrdiff_t	N/A
x X	Konvertiert eine vorzeichenlose Ganzzahl in die Hexadezimaldarstellung hhhh. Für die x-Konversionsbuchstaben werden abcdef verwendet. Für die X-Konversionsbuchstaben werden ABCDEF verwendet. Genauigkeit gibt die minimale Anzahl der anzuzeigenden Ziffern an. Die Standardgenauigkeit ist 1. Wenn sowohl der konvertierte Wert als auch die Genauigkeit ​0​ sind, erzeugt die Konversion keine Zeichen. In der alternativen Implementierung wird den Ergebnissen 0x oder 0X vorangestellt, wenn der konvertierte Wert ungleich Null ist.									N/A
u	Konvertiert eine vorzeichenlose Ganzzahl in die Dezimaldarstellung dddd. Genauigkeit gibt die minimale Anzahl der anzuzeigenden Ziffern an. Die Standardgenauigkeit ist 1. Wenn sowohl der konvertierte Wert als auch die Genauigkeit ​0​ sind, erzeugt die Konversion keine Zeichen.									N/A
f F (C++11)	Konvertiert eine Gleitkommazahl in die Dezimalnotation im Stil [-]ddd.ddd. Genauigkeit gibt die genaue Anzahl der Ziffern nach dem Dezimaltrennzeichen an. Die Standardgenauigkeit ist 6. In der alternativen Implementierung wird das Dezimaltrennzeichen auch dann geschrieben, wenn keine Ziffern darauf folgen. Informationen zur Konversion von Unendlichkeit und Nicht-Zahl im Hinblick auf den Stil finden Sie unter Anmerkungen.	N/A	N/A	double	double (C++11)	N/A	N/A	N/A	N/A	long double
e E	Konvertiert eine Gleitkommazahl in die Dezimal-Exponent-Notation. Für den e-Konversionsstil wird [-]d.ddd e±dd verwendet. Für den E-Konversionsstil wird [-]d.ddd E±dd verwendet. Der Exponent enthält mindestens zwei Ziffern, mehr Ziffern werden nur bei Bedarf verwendet. Wenn der Wert ​0​ ist, ist auch der Exponent ​0​. Genauigkeit gibt die genaue Anzahl der Ziffern nach dem Dezimaltrennzeichen an. Die Standardgenauigkeit ist 6. In der alternativen Implementierung wird das Dezimaltrennzeichen auch dann geschrieben, wenn keine Ziffern darauf folgen. Informationen zur Konversion von Unendlichkeit und Nicht-Zahl im Hinblick auf den Stil finden Sie unter Anmerkungen.	N/A	N/A			N/A	N/A	N/A	N/A
a A (C++11)	Konvertiert eine Gleitkommazahl in die Hexadezimal-Exponent-Notation. Für den a-Konversionsstil wird [-] 0xh.hhh p±d verwendet. Für den A-Konversionsstil wird [-] 0Xh.hhh P±d verwendet. Die erste Hexadezimalziffer ist nicht 0, wenn das Argument ein normalisierter Gleitkommawert ist. Wenn der Wert ​0​ ist, ist auch der Exponent ​0​. Genauigkeit gibt die exakte Anzahl der Ziffern nach dem Hexadezimaltrennzeichen an. Die Standardgenauigkeit ist ausreichend für die exakte Darstellung des Wertes. In der alternativen Implementierung wird das Dezimaltrennzeichen auch dann geschrieben, wenn keine Ziffern darauf folgen. Informationen zur Konversion von Unendlichkeit und Nicht-Zahl im Hinblick auf den Stil finden Sie unter Anmerkungen.	N/A	N/A			N/A	N/A	N/A	N/A
g G	Konvertiert eine Gleitkommazahl je nach Wert und Genauigkeit in die Dezimal- oder Dezimal-Exponent-Notation. Für den g-Konversionsstil wird die Konversion mit dem Stil e oder f durchgeführt. Für den G-Konversionsstil wird die Konversion mit dem Stil E oder f(bis C++11)F(seit C++11) durchgeführt. Sei P gleich der Genauigkeit, wenn diese ungleich Null ist, 6, wenn die Genauigkeit nicht angegeben ist, oder 1, wenn die Genauigkeit ​0​ ist. Dann, wenn eine Konversion im Stil E einen Exponenten von X hätte: Wenn P > X ≥ −4, erfolgt die Konversion im Stil f oder F(seit C++11) mit einer Genauigkeit von P − 1 − X. Andernfalls erfolgt die Konversion im Stil e oder E mit einer Genauigkeit von P − 1. Sofern keine alternative Darstellung angefordert wird, werden nachfolgende Nullen entfernt, und das Dezimaltrennzeichen wird entfernt, wenn kein Bruchteil übrig bleibt. Informationen zur Konversion von Unendlichkeit und Nicht-Zahl im Hinblick auf den Stil finden Sie unter Anmerkungen.	N/A	N/A			N/A	N/A	N/A	N/A
n	Gibt die bisher von diesem Funktionsaufruf geschriebene Anzahl der Zeichen zurück. Das Ergebnis wird an den Wert geschrieben, auf den das Argument zeigt. Die Spezifikation darf keine Flags, Feldbreiten oder Genauigkeiten enthalten. Für den z-Modifikator ist der erwartete Argumenttyp S*, wobei S die vorzeichenbehaftete Version von std::size_t ist.	signed char*	short*	int*	long*	long long*	std::intmax_t*	※	std::ptrdiff_t*	N/A
p	Schreibt eine implementierungsdefinierte Zeichensequenz, die einen Zeiger darstellt.	N/A	N/A	void*	N/A	N/A	N/A	N/A	N/A	N/A
Anmerkungen
Die Gleitkommakonversionsfunktionen konvertieren Unendlichkeit in inf oder infinity. Welche Variante verwendet wird, ist implementierungsabhängig. Nicht-Zahlen werden in nan oder nan(char_sequence) konvertiert. Welche Variante verwendet wird, ist implementierungsabhängig. Die Konversionen F, E, G, A geben stattdessen INF, INFINITY, NAN aus. Die Konversionsspezifizierer zur Ausgabe von char, unsigned char, signed char, short und unsigned short erwarten promotionierte Typen gemäß den Standard-Argument-Promotions, aber bevor ihr Wert ausgegeben wird, wird er in char, unsigned char, signed char, short und unsigned short konvertiert. Es ist sicher, Werte dieser Typen zu übergeben, da die Promotion stattfindet, wenn eine variadische Funktion aufgerufen wird. Die korrekten Konversionsspezifizierer für zeichenfeste Breiten-Typen (std::int8_t, etc.) sind im Header <cinttypes> definiert (obwohl PRIdMAX, PRIuMAX, etc. synonym mit %jd, %ju, etc. sind). Der speicherschreibende Konversionsspezifizierer %n ist ein häufiges Ziel von Sicherheitslücken, bei denen Formatzeichenketten von Benutzereingaben abhängen. Es gibt einen Sequenzpunkt nach der Ausführung jedes Konversionsspezifizierers; dies ermöglicht das Speichern mehrerer %n-Ergebnisse in derselben Variablen oder, als Randfall, das Drucken einer Zeichenkette, die durch ein früheres %n innerhalb desselben Aufrufs modifiziert wurde. Wenn eine Konversionsspezifikation 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 (ausschließlich des terminierenden Nullzeichens) oder ein negativer Wert bei einem Fehler.

4) Anzahl der Zeichen, die für einen ausreichend großen Puffer bei Erfolg geschrieben worden wären (ausschließlich des terminierenden Nullzeichens), oder ein negativer Wert bei einem Fehler. Somit wurde die (null-terminierte) Ausgabe vollständig geschrieben, wenn und nur wenn der zurückgegebene Wert nicht-negativ und kleiner als buf_size ist.

Anmerkungen

POSIX schreibt vor, dass errno bei einem Fehler gesetzt wird. Es schreibt auch zusätzliche Konversionsspezifikationen vor, insbesondere die Unterstützung für Argument-Reihenfolge (n$ unmittelbar nach % kennzeichnet das n-te Argument).

Das Aufrufen von std::snprintf mit null buf_size und einem Nullzeiger für buffer ist nützlich (wenn der Overhead eines doppelten Aufrufs akzeptabel ist), um die notwendige Puffergröße zu ermitteln, um die Ausgabe aufzunehmen.

auto fmt = "sqrt(2) = %f";
int sz = std::snprintf(nullptr, 0, fmt, std::sqrt(2));
std::vector<char> buf(sz + 1); // note +1 for null terminator
std::sprintf(buf.data(), fmt, std::sqrt(2)); // certain to fit

Beispiel

Führen Sie diesen Code aus

#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

wprintffwprintfswprintf	druckt formatierte breite Zeichen-Ausgabe nach stdout, einem Dateistream oder einem Puffer (Funktion)
vprintfvfprintfvsprintfvsnprintf (C++11)	druckt formatierte Ausgabe nach stdout, einen Dateistream oder einen Puffer mit variabler Argumentenliste (function)
fputs	schreibt einen Zeichenstring in einen Dateistream (function)
scanffscanfsscanf	liest formatierte Eingaben von stdin, einem Dateistream oder einem Puffer (Funktion)
to_chars (C++17)	konvertiert einen Ganzzahl- oder Gleitkommawert in eine Zeichensequenz (Funktion)
print (C++23)	druckt nach stdout oder einem Dateistream unter Verwendung der formatierten Darstellung der Argumente (Funktionstemplate)
println (C++23)	dasselbe wie std::print, außer dass jeder Druck durch eine zusätzliche neue Zeile beendet wird (Funktionstemplate)
C-Dokumentation für printf, fprintf, sprintf, snprintf