Input/output library

C++ beinhaltet die folgenden Eingabe-/Ausgabebibliotheken: eine OOP-orientierte Stream-basierte I/O -Bibliothek , Print-basierte Funktionsfamilie (seit C++23) , und den Standardsatz von C-style I/O -Funktionen.

Inhaltsverzeichnis 1 Stream-basierte E/A 1.1 Abstraktion 1.2 Datei-E/A-Implementierung 1.3 String-E/A-Implementierung 1.4 Array-E/A-Implementierungen 1.5 Synchronisierte Ausgabe (seit C++20) 1.6 Typdefinitionen 1.7 Vordefinierte Standard-Stream-Objekte 1.8 E/A-Manipulatoren 1.9 Typen 1.10 Fehlerkategorie-Schnittstelle (seit C++11) 2 Druckfunktionen (seit C++23) 3 C-Stil-E/A 4 Siehe auch

Stream-basierte E/A

Die stream-basierte Eingabe-/Ausgabebibliothek ist um abstrakte Eingabe-/Ausgabegeräte organisiert. Diese abstrakten Geräte ermöglichen es demselben Code, Eingaben/Ausgaben zu Dateien, Speicherstreams oder benutzerdefinierten Adaptergeräten zu verarbeiten, die beliebige Operationen (z.B. Komprimierung) on-the-fly durchführen.

Die meisten Klassen sind als Templates implementiert, sodass sie an jeden grundlegenden Zeichentyp angepasst werden können. Separate Typdefinitionen sind für die gebräuchlichsten grundlegenden Zeichentypen verfügbar ( char und wchar_t ). Die Klassen sind in der folgenden Hierarchie organisiert:

Abstraktion
Definiert in Header <ios>
ios_base	verwaltet Formatierungsflags und Eingabe-/Ausgabeausnahmen (Klasse)
basic_ios	verwaltet einen beliebigen Streampuffer (Klassentemplate)
Definiert in Header <streambuf>
basic_streambuf	abstrahiert ein Rohgerät (Klassentemplate)
Definiert in Header <ostream>
basic_ostream	umschließt ein gegebenes abstraktes Gerät ( std::basic_streambuf ) und bietet eine hochwertige Ausgabeschnittstelle (Klassentemplate)
Definiert im Header <istream>
basic_istream	umschließt ein gegebenes abstraktes Gerät ( std::basic_streambuf ) und bietet eine hochwertige Eingabeschnittstelle (Klassentemplate)
basic_iostream	umschließt ein gegebenes abstraktes Gerät ( std::basic_streambuf ) und bietet eine hochwertige Eingabe/Ausgabe-Schnittstelle (Klassentemplate)
Datei-I/O-Implementierung
Definiert in Header <fstream>
basic_filebuf	implementiert Rohdatei-Gerät (Klassentemplate)
basic_ifstream	implementiert High-Level-Dateistrom-Eingabeoperationen (Klassentemplate)
basic_ofstream	implementiert High-Level-Dateistream-Ausgabeoperationen (Klassentemplate)
basic_fstream	implementiert hochlevel Dateistrom-Ein-/Ausgabeoperationen (Klassentemplate)
String-I/O-Implementierung
Definiert in Header <sstream>
basic_stringbuf	implementiert Roh-String-Gerät (Klassentemplate)
basic_istringstream	implementiert High-Level String-Stream-Eingabeoperationen (Klassentemplate)
basic_ostringstream	implementiert High-Level String-Stream-Ausgabeoperationen (Klassentemplate)
basic_stringstream	implementiert High-Level String-Stream-Ein-/Ausgabeoperationen (Klassentemplate)
Array-I/O-Implementierungen
Definiert in Header <spanstream>
basic_spanbuf (C++23)	implementiert ein Roh-Fixed-Character-Puffer-Gerät (Klassentemplate)
basic_ispanstream (C++23)	implementiert Eingabeoperationen für feste Zeichenpuffer (Klassentemplate)
basic_ospanstream (C++23)	implementiert Ausgabeoperationen für feste Zeichenpuffer (Klassentemplate)
basic_spanstream (C++23)	implementiert Eingabe-/Ausgabeoperationen für feste Zeichenpuffer (Klassentemplate)
Definiert im Header <strstream>
strstreambuf (in C++98 veraltet) (in C++26 entfernt)	implementiert ein Roh-Zeichenarray-Gerät (Klasse)
istrstream (in C++98 veraltet) (in C++26 entfernt)	implementiert Zeichenarray-Eingabeoperationen (Klasse)
ostrstream (veraltet in C++98) (entfernt in C++26)	implementiert Zeichenarray-Ausgabeoperationen (Klasse)
strstream (veraltet in C++98) (entfernt in C++26)	implementiert Eingabe-/Ausgabeoperationen für Zeichenarrays (Klasse)
Synchronisierte Ausgabe (since C++20)
Definiert im Header <syncstream>
basic_syncbuf (C++20)	Synchronisierte Ausgabegeräte-Wrapper (Klassentemplate)
basic_osyncstream (C++20)	Synchronisierter Ausgabestrom-Wrapper (Klassentemplate)

Typedefs

Die folgenden Typdefinitionen für gebräuchliche Zeichentypen werden im Namensraum 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 im 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 im Header <ostream>
std::ostream	std:: basic_ostream < char >
std::wostream	std:: basic_ostream < wchar_t >
Definiert im 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 im 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 im Header <iostream>
cin wcin	liest vom standard C-Eingabestrom stdin (globales Objekt)
cout wcout	schreibt in den standard C-Ausgabestrom stdout (globales Objekt)
cerr wcerr	schreibt in den standard C-Fehlerstrom stderr , ungepuffert (globales Objekt)
clog wclog	schreibt in den standard C-Fehlerstrom stderr (globales Objekt)

I/O-Manipulatoren

Die stream-basierte E/A-Bibliothek verwendet I/O-Manipulatoren (z.B. std::boolalpha , std::hex , etc.), um das Verhalten von Streams zu steuern.

Typen

Die folgenden Hilfstypen sind definiert:

Definiert im Header <ios>
streamoff	repräsentiert relative Datei-/Stream-Position (Offset von fpos), ausreichend um jede Dateigröße darzustellen (typedef)
streamsize	repräsentiert die Anzahl der übertragenen Zeichen in einem I/O-Vorgang oder die Größe eines I/O-Puffers (typedef)
fpos	repräsentiert absolute Position in einem Stream oder einer Datei (class template)

Die folgenden Typedef-Namen für std:: fpos < std:: mbstate_t > werden bereitgestellt:

Definiert im 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 im Header <ios>
io_errc (C++11)	die IO-Stream-Fehlercodes (enum)
iostream_category (C++11)	identifiziert die iostream-Fehlerkategorie (Funktion)

Druckfunktionen (since C++23)

Die Unicode-fähigen Print-Funktionen, die formatierten I/O auf bereits formatiertem Text durchführen. Sie bieten alle Leistungsvorteile von std::format , sind standardmäßig gebietsschemaineu, reduzieren globalen Zustand, vermeiden die Allokation eines temporären std::string -Objekts und den Aufruf von operator << und machen die Formatierung im Allgemeinen effizienter im Vergleich zu iostreams und stdio .

Die folgenden druckähnlichen Funktionen werden bereitgestellt:

Definiert im Header <print>
print (C++23)	gibt auf stdout oder einen Dateistrom unter Verwendung einer formatierten Darstellung der Argumente aus (Funktionstemplate)
println (C++23)	identisch mit std::print , außer dass jede Ausgabe durch eine zusätzliche neue Zeile abgeschlossen wird (Funktionstemplate)
vprint_unicode vprint_unicode_buffered (C++23)	gibt auf Unicode-fähigem stdout oder einem Dateistrom unter Verwendung einer typeradierten Argumentdarstellung aus (Funktion)
vprint_nonunicode vprint_nonunicode_buffered (C++23)	gibt auf stdout oder einem Dateistrom unter Verwendung einer typeradierten Argumentdarstellung aus (Funktion)
Definiert im Header <ostream>
print (std::ostream) (C++23)	gibt eine formatierte Darstellung der Argumente aus (Funktionstemplate)
println (std::ostream) (C++23)	gibt eine formatierte Darstellung der Argumente mit angehängtem ' \n ' aus (Funktionstemplate)

C-style I/O

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

Siehe auch

Filesystem-Bibliothek (seit C++17)