Input/output library

C++ inclut les bibliothèques d'entrée/sortie suivantes : une bibliothèque d'I/O orientée flux de style POO , famille de fonctions basée sur l'impression (depuis C++23) , et l'ensemble standard des fonctions d'I/O de style C .

Table des matières 1 Entrées/sorties basées sur les flux 1.1 Abstraction 1.2 Implémentation des E/S de fichiers 1.3 Implémentation des E/S de chaînes 1.4 Implémentations des E/S de tableaux 1.5 Sortie synchronisée (depuis C++20) 1.6 Typedefs 1.7 Objets de flux standard prédéfinis 1.8 Manipulateurs d'E/S 1.9 Types 1.10 Interface de catégorie d'erreur (depuis C++11) 2 Fonctions d'impression (depuis C++23) 3 Entrées/sorties de style C 4 Voir aussi

Entrées/Sorties basées sur les flux

La bibliothèque d'entrée/sortie basée sur les flux est organisée autour de dispositifs d'entrée/sortie abstraits. Ces dispositifs abstraits permettent au même code de gérer l'entrée/sortie vers des fichiers, des flux mémoire, ou des dispositifs adaptateurs personnalisés qui effectuent des opérations arbitraires (par exemple, la compression) à la volée.

La plupart des classes sont basées sur des templates, ce qui permet de les adapter à tout type de caractère de base. Des typedefs distincts sont fournis pour les types de caractères de base les plus courants ( char et wchar_t ). Les classes sont organisées selon la hiérarchie suivante :

Abstraction
Défini dans l'en-tête <ios>
ios_base	gère les indicateurs de formatage et les exceptions d'entrée/sortie (classe)
basic_ios	gère un tampon de flux arbitraire (modèle de classe)
Défini dans l'en-tête <streambuf>
basic_streambuf	abstrait un périphérique brut (modèle de classe)
Défini dans l'en-tête <ostream>
basic_ostream	encapsule un dispositif abstrait donné ( std::basic_streambuf ) et fournit une interface de sortie de haut niveau (modèle de classe)
Défini dans l'en-tête <istream>
basic_istream	encapsule un dispositif abstrait donné ( std::basic_streambuf ) et fournit une interface d'entrée de haut niveau (modèle de classe)
basic_iostream	encapsule un dispositif abstrait donné ( std::basic_streambuf ) et fournit une interface d'entrée/sortie de haut niveau (modèle de classe)
Implémentation d'E/S de fichiers
Défini dans l'en-tête <fstream>
basic_filebuf	implémente un périphérique de fichier brut (modèle de classe)
basic_ifstream	implémente les opérations d'entrée de flux de fichier de haut niveau (modèle de classe)
basic_ofstream	implémente les opérations de sortie de flux de fichiers de haut niveau (modèle de classe)
basic_fstream	implémente les opérations d'entrée/sortie de flux de fichiers de haut niveau (modèle de classe)
Implémentation des E/S de chaînes
Défini dans l'en-tête <sstream>
basic_stringbuf	implémente un périphérique de chaîne brut (modèle de classe)
basic_istringstream	implémente les opérations d'entrée de flux de chaîne de haut niveau (modèle de classe)
basic_ostringstream	implémente les opérations de sortie de flux de chaîne de haut niveau (modèle de classe)
basic_stringstream	implémente les opérations d'entrée/sortie de flux de chaîne de haut niveau (modèle de classe)
Implémentations d'E/S de tableaux
Défini dans l'en-tête <spanstream>
basic_spanbuf (C++23)	implémente un périphérique de tampon de caractères brut fixe (modèle de classe)
basic_ispanstream (C++23)	implémente les opérations d'entrée sur tampon de caractères fixe (modèle de classe)
basic_ospanstream (C++23)	implémente les opérations de sortie sur tampon de caractères fixe (modèle de classe)
basic_spanstream (C++23)	implémente les opérations d'entrée/sortie sur tampon de caractères fixe (modèle de classe)
Défini dans l'en-tête <strstream>
strstreambuf (déprécié en C++98) (supprimé en C++26)	implémente un périphérique de tableau de caractères brut (classe)
istrstream (obsolète en C++98) (supprimé en C++26)	implémente les opérations d'entrée sur des tableaux de caractères (classe)
ostrstream (obsolète en C++98) (supprimé en C++26)	implémente les opérations de sortie sur des tableaux de caractères (classe)
strstream (obsolète en C++98) (supprimé en C++26)	implémente les opérations d'entrée/sortie sur des tableaux de caractères (classe)
Sortie synchronisée (depuis C++20)
Défini dans l'en-tête <syncstream>
basic_syncbuf (C++20)	wrapper de périphérique de sortie synchronisé (modèle de classe)
basic_osyncstream (C++20)	wrapper de flux de sortie synchronisé (modèle de classe)

Typedefs

Les typedefs suivants pour les types de caractères courants sont fournis dans l'espace de noms std :

Type	Définition
Défini dans l'en-tête <ios>
std::ios	std:: basic_ios < char >
std::wios	std:: basic_ios < wchar_t >
Défini dans l'en-tête <streambuf>
std::streambuf	std:: basic_streambuf < char >
std::wstreambuf	std:: basic_streambuf < wchar_t >
Défini dans l'en-tête <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 >
Défini dans l'en-tête <ostream>
std::ostream	std:: basic_ostream < char >
std::wostream	std:: basic_ostream < wchar_t >
Défini dans l'en-tête <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 >
Défini dans l'en-tête <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 >
Défini dans l'en-tête <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 >
Défini dans l'en-tête <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 >

Objets de flux standard prédéfinis

Défini dans l'en-tête <iostream>
cin wcin	lit depuis le flux d'entrée standard C stdin (objet global)
cout wcout	écrit vers le flux de sortie standard C stdout (objet global)
cerr wcerr	écrit vers le flux d'erreur standard C stderr , non tamponné (objet global)
clog wclog	écrit vers le flux d'erreur standard C stderr (objet global)

Manipulateurs d'E/S

La bibliothèque d'E/S basée sur les flux utilise les manipulateurs d'E/S (par exemple std::boolalpha , std::hex , etc.) pour contrôler le comportement des flux.

Types

Les types auxiliaires suivants sont définis :

Défini dans l'en-tête <ios>
streamoff	représente la position relative d'un fichier/flux (décalage depuis fpos), suffisant pour représenter n'importe quelle taille de fichier (typedef)
streamsize	représente le nombre de caractères transférés dans une opération d'E/S ou la taille d'un tampon d'E/S (typedef)
fpos	représente la position absolue dans un flux ou un fichier (modèle de classe)

Les noms typedef suivants pour std:: fpos < std:: mbstate_t > sont fournis :

Défini dans l'en-tête <iosfwd>
Type	Définition
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 >

Interface de catégorie d'erreur (depuis C++11)

Défini dans l'en-tête <ios>
io_errc (C++11)	les codes d'erreur des flux d'E/S (enumération)
iostream_category (C++11)	identifie la catégorie d'erreur des iostream (fonction)

Fonctions d'impression (depuis C++23)

Les fonctions de la famille print prenant en charge Unicode qui effectuent des E/S formatées sur du texte déjà formaté. Elles apportent tous les avantages de performance de std::format , sont indépendantes des locales par défaut, réduisent l'état global, évitent l'allocation d'un objet temporaire std::string et l'appel à operator << , et en général rendent le formatage plus efficace comparé aux iostreams et à stdio .

Les fonctions d'impression suivantes sont fournies :

Défini dans l'en-tête <print>
print (C++23)	imprime vers stdout ou un flux de fichier en utilisant la représentation formatée des arguments (modèle de fonction)
println (C++23)	identique à std::print sauf que chaque impression est terminée par un saut de ligne supplémentaire (modèle de fonction)
vprint_unicode vprint_unicode_buffered (C++23)	imprime vers stdout compatible Unicode ou un flux de fichier en utilisant la représentation type-erased des arguments (fonction)
vprint_nonunicode vprint_nonunicode_buffered (C++23)	imprime vers stdout ou un flux de fichier en utilisant la représentation type-erased des arguments (fonction)
Défini dans l'en-tête <ostream>
print (std::ostream) (C++23)	produit la représentation formatée des arguments (modèle de fonction)
println (std::ostream) (C++23)	produit la représentation formatée des arguments avec ajout de ' \n ' (modèle de fonction)

Entrées/Sorties de style C

C++ inclut également les fonctions d'entrée/sortie définies par C , telles que std::fopen , std::getc , etc.

Voir aussi

Bibliothèque de système de fichiers (depuis C++17)