Ein-/Ausgabe-Bibliothek

 

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++ beinhaltet die folgenden Ein-/Ausgabe-Bibliotheken: eine OOP-orientierte Stream-basierte I/O-Bibliothek, eine Familie von Print-FunktionenPrint-Funktionen(seit C++23) und die Standardmenge an C-Style I/O-Funktionen.

Stream-basierte I/O

Die stream-basierte Ein-/Ausgabe-Bibliothek ist um abstrakte Ein-/Ausgabe-Geräte herum organisiert. Diese abstrakten Geräte ermöglichen es, mit demselben Code Ein-/Ausgabe für Dateien, Speicher-Streams oder benutzerdefinierte Adaptergeräte durchzuführen, die beliebige Operationen (z. B. Komprimierung) "on the fly" ausführen.

Die meisten Klassen sind templates, sodass sie an jeden grundlegenden Zeichentyp angepasst werden können. Für die gängigsten grundlegenden Zeichentypen (char und wchar_t) werden separate Typdeklarationen bereitgestellt. Die Klassen sind in folgender Hierarchie organisiert:

Vererbungdiagramm

Abstraktion
Definiert in Header <ios>
ios_base	verwaltet Formatierungsflags und Ein-/Ausgabe-Exceptions (Klasse)
basic_ios	verwaltet einen beliebigen Stream-Puffer (Klassen-Template)
Definiert in Header <streambuf>
basic_streambuf	abstrahiert ein Rohgerät (class template)
Definiert in Header <ostream>
basic_ostream	kapselt ein gegebenes abstraktes Gerät (std::basic_streambuf) und stellt eine High-Level-Ausgabeschnittstelle bereit (class template)
Definiert in Header <istream>
basic_istream	kapselt ein gegebenes abstraktes Gerät (std::basic_streambuf) und stellt eine High-Level-Eingabeschnittstelle bereit (class template)
basic_iostream	kapselt ein gegebenes abstraktes Gerät (std::basic_streambuf) und stellt eine High-Level-Ein-/Ausgabe-Schnittstelle bereit (Klassen-Template)
Implementierung von Datei-I/O
Definiert in Header <fstream>
basic_filebuf	implementiert rohe Datei-Geräte (Klassen-Template)
basic_ifstream	implementiert High-Level-Datei-Stream-Eingabeoperationen (Klassen-Template)
basic_ofstream	implementiert High-Level-Datei-Stream-Ausgabeoperationen (Klassen-Template)
basic_fstream	implementiert High-Level-Datei-Stream-Ein-/Ausgabeoperationen (Klassen-Template)
Implementierung von String-I/O
Definiert in Header <sstream>
basic_stringbuf	implementiert rohe String-Geräte (Klassen-Template)
basic_istringstream	implementiert High-Level-String-Stream-Eingabeoperationen (Klassen-Template)
basic_ostringstream	implementiert High-Level-String-Stream-Ausgabeoperationen (Klassen-Template)
basic_stringstream	implementiert High-Level-String-Stream-Ein-/Ausgabeoperationen (Klassen-Template)
Implementierung von Array-I/O
Definiert in Header <spanstream>
basic_spanbuf (C++23)	implementiert rohe Puffergeräte mit festen Zeichen (Klassen-Template)
basic_ispanstream (C++23)	implementiert Eingabeoperationen für Puffer mit festen Zeichen (Klassen-Template)
basic_ospanstream (C++23)	implementiert Ausgabeoperationen für Puffer mit festen Zeichen (Klassen-Template)
basic_spanstream (C++23)	implementiert Ein-/Ausgabeoperationen für Puffer mit festen Zeichen (Klassen-Template)
Definiert in Header <strstream>
strstreambuf (in C++98 veraltet)(in C++26 entfernt)	implementiert rohe Zeichen-Array-Geräte (Klasse)
istrstream (in C++98 veraltet)(in C++26 entfernt)	implementiert Zeichen-Array-Eingabeoperationen (Klasse)
ostrstream (in C++98 veraltet)(in C++26 entfernt)	implementiert Zeichen-Array-Ausgabeoperationen (Klasse)
strstream (in C++98 veraltet)(in C++26 entfernt)	implementiert Zeichen-Array-Ein-/Ausgabeoperationen (Klasse)
Synchronisierte Ausgabe (seit C++20)
Definiert in Header <syncstream>
basic_syncbuf (C++20)	Wrapper für synchronisierte Ausgabegeräte (Klassen-Template)
basic_osyncstream (C++20)	Wrapper für synchronisierte Ausgabe-Streams (Klassen-Template)

Typdeklarationen

Die folgenden Typdeklarationen für gängige Zeichentypen sind im Namespace std bereitgestellt:

Typ	Definition
Definiert in Header <ios>
std::ios	std::basic_ios<char>
std::wios	std::basic_ios<wchar_t>
Definiert in Header <streambuf>
std::streambuf	std::basic_streambuf<char>
std::wstreambuf	std::basic_streambuf<wchar_t>
Definiert in Header <istream>
std::istream	std::basic_istream<char>
std::wistream	std::basic_istream<wchar_t>
std::iostream	std::basic_iostream<char>
std::wiostream	std::basic_iostream<wchar_t>
Definiert in Header <ostream>
std::ostream	std::basic_ostream<char>
std::wostream	std::basic_ostream<wchar_t>
Definiert in Header <fstream>
std::filebuf	std::basic_filebuf<char>
std::wfilebuf	std::basic_filebuf<wchar_t>
std::ifstream	std::basic_ifstream<char>
std::wifstream	std::basic_ifstream<wchar_t>
std::ofstream	std::basic_ofstream<char>
std::wofstream	std::basic_ofstream<wchar_t>
std::fstream	std::basic_fstream<char>
std::wfstream	std::basic_fstream<wchar_t>
Definiert in Header <sstream>
std::stringbuf	std::basic_stringbuf<char>
std::wstringbuf	std::basic_stringbuf<wchar_t>
std::istringstream	std::basic_istringstream<char>
std::wistringstream	std::basic_istringstream<wchar_t>
std::ostringstream	std::basic_ostringstream<char>
std::wostringstream	std::basic_ostringstream<wchar_t>
std::stringstream	std::basic_stringstream<char>
std::wstringstream	std::basic_stringstream<wchar_t>
Definiert in Header <spanstream>
std::spanbuf (C++23)	std::basic_spanbuf<char>
std::wspanbuf (C++23)	std::basic_spanbuf<wchar_t>
std::ispanstream (C++23)	std::basic_ispanstream<char>
std::wispanstream (C++23)	std::basic_ispanstream<wchar_t>
std::ospanstream (C++23)	std::basic_ospanstream<char>
std::wospanstream (C++23)	std::basic_ospanstream<wchar_t>
std::spanstream (C++23)	std::basic_spanstream<char>
std::wspanstream (C++23)	std::basic_spanstream<wchar_t>
Definiert in Header <syncstream>
std::syncbuf (C++20)	std::basic_syncbuf<char>
std::wsyncbuf (C++20)	std::basic_syncbuf<wchar_t>
std::osyncstream (C++20)	std::basic_osyncstream<char>
std::wosyncstream (C++20)	std::basic_osyncstream<wchar_t>

Vordefinierte Standard-Stream-Objekte

Definiert in Header <iostream>
cinwcin	liest vom Standard-C-Eingabestrom stdin (globales Objekt)
coutwcout	schreibt in den Standard-C-Ausgabestrom stdout (globales Objekt)
cerrwcerr	schreibt in den Standard-C-Fehlerstrom stderr, unbuffered (globales Objekt)
clogwclog	schreibt in den Standard-C-Fehlerstrom stderr (globales Objekt)

I/O-Manipulatoren

Die stream-basierte I/O-Bibliothek verwendet I/O-Manipulatoren (z. B. std::boolalpha, std::hex usw.), um zu steuern, wie Streams sich verhalten.

Typen

Die folgenden Hilfstypen sind definiert:

Definiert in Header <ios>
streamoff	repräsentiert die relative Dateiposition (Offset von fpos), ausreichend zur Darstellung jeder Dateigröße (Typdeklaration)
streamsize	repräsentiert die Anzahl der in einer I/O-Operation übertragenen Zeichen oder die Größe eines I/O-Puffers (Typdeklaration)
fpos	repräsentiert die absolute Position in einem Stream oder einer Datei (Klassen-Template)

Die folgenden Typdeklarationen für std::fpos<std::mbstate_t> werden bereitgestellt:

Definiert in Header <iosfwd>
Typ	Definition
std::streampos	std::fpos<std::char_traits<char>::state_type>
std::wstreampos	std::fpos<std::char_traits<wchar_t>::state_type>
std::u8streampos (C++20)	std::fpos<std::char_traits<char8_t>::state_type>
std::u16streampos (C++11)	std::fpos<std::char_traits<char16_t>::state_type>
std::u32streampos (C++11)	std::fpos<std::char_traits<char32_t>::state_type>

Fehlerkategorie-Schnittstelle (seit C++11)

Definiert in Header <ios>
io_errc (C++11)	die IO-Stream-Fehlercodes (Aufzählung)
iostream_category (C++11)	identifiziert die iostream-Fehlerkategorie (Funktion)

Print-Funktionen (seit C++23)

Die Unicode-fähigen Print-Familienfunktionen, die formatierten I/O auf Text durchführen, der bereits formatiert ist. Sie bringen alle Leistungsvorteile von std::format, sind standardmäßig sprachunabhängig, reduzieren globale Zustände, vermeiden die Zuweisung eines temporären std::string-Objekts und den Aufruf von operator<< und machen im Allgemeinen die Formatierung effizienter im Vergleich zu iostreams und stdio.

Die folgenden print-ähnlichen Funktionen werden bereitgestellt:

Definiert in Header <print>
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)
vprint_unicodevprint_unicode_buffered (C++23)	druckt auf Unicode-fähige stdout oder einen Dateistream unter Verwendung der typ-erased Argumentdarstellung (Funktion)
vprint_nonunicodevprint_nonunicode_buffered (C++23)	druckt auf stdout oder einen Dateistream unter Verwendung der typ-erased Argumentdarstellung (Funktion)
Definiert in Header <ostream>
print(std::ostream) (C++23)	gibt die formatierten Darstellung der Argumente aus (Funktionstemplate)
println(std::ostream) (C++23)	gibt die formatierten Darstellung der Argumente mit angehängtem '\n' aus (Funktions-Template)

C-Style I/O

C++ beinhaltet auch die von C definierten Ein-/Ausgabe-Funktionen, wie z. B. std::fopen, std::getc usw.

Siehe auch

Dateisystem-Bibliothek (seit C++17)