Namespaces
Variants

Standard library header <iosfwd>

From cppreference.net
C++
Standard library headers

Cet en-tête contient les déclarations anticipées pour la bibliothèque d'entrée/sortie .

Déclarations anticipées

Défini dans l'en-tête <string>
std::char_traits Modèle de classe qui décrit les propriétés d'un type de caractère (modèle de classe)
std:: char_traits < char > (spécialisation de modèle de classe)
std:: char_traits < wchar_t > (spécialisation de modèle de classe)
std:: char_traits < char8_t > (C++20) (spécialisation de modèle de classe)
std:: char_traits < char16_t > (C++11) (spécialisation de modèle de classe)
std:: char_traits < char32_t > (C++11) (spécialisation de modèle de classe)
Défini dans l'en-tête <memory>
l'allocateur par défaut
(modèle de classe)
Défini dans l'en-tête <ios>
gère un tampon de flux arbitraire
(modèle de classe)
représente une position absolue dans un flux ou un fichier
(modèle de classe)
Défini dans l'en-tête <streambuf>
abstrait un périphérique brut
(modèle de classe)
Défini dans l'en-tête <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>
encapsule un dispositif abstrait donné ( std::basic_streambuf )
et fournit une interface d'entrée de haut niveau
(modèle de classe)
encapsule un dispositif abstrait donné ( std::basic_streambuf )
et fournit une interface d'entrée/sortie de haut niveau
(modèle de classe)
Défini dans l'en-tête <fstream>
implémente le périphérique de fichier brut
(modèle de classe)
implémente les opérations d'entrée de flux de fichier de haut niveau
(modèle de classe)
implémente les opérations de sortie de flux de fichiers de haut niveau
(modèle de classe)
implémente les opérations d'entrée/sortie de flux de fichiers de haut niveau
(modèle de classe)
Défini dans l'en-tête <sstream>
implémente un périphérique de chaîne brut
(modèle de classe)
implémente les opérations d'entrée de flux de chaîne de haut niveau
(modèle de classe)
implémente les opérations de sortie de flux de chaîne de haut niveau
(modèle de classe)
implémente les opérations d'entrée/sortie de flux de chaînes de haut niveau
(modèle de classe)
Défini dans l'en-tête <syncstream>
(C++20)
enveloppe de périphérique de sortie synchronisé
(modèle de classe)
(C++20)
wrapper de flux de sortie synchronisé
(modèle de classe)
Défini dans l'en-tête <spanstream>
(C++23)
implémente un périphérique de tampon de caractères brut fixe
(modèle de classe)
(C++23)
implémente les opérations d'entrée sur tampon de caractères fixe
(modèle de classe)
(C++23)
implémente les opérations de sortie sur tampon de caractères fixe
(modèle de classe)
(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>
(déprécié en C++98) (supprimé en C++26)
implémente un périphérique de tableau de caractères brut
(classe)
(obsolète en C++98) (supprimé en C++26)
implémente les opérations d'entrée sur des tableaux de caractères
(classe)
(déprécié en C++98) (supprimé en C++26)
implémente les opérations de sortie sur des tableaux de caractères
(classe)
(déprécié en C++98) (supprimé en C++26)
implémente les opérations d'entrée/sortie sur des tableaux de caractères
(classe)

Typedefs et spécialisations

std::streampos std:: fpos < std:: char_traits < char > :: state_type >
std::wstreampos std:: fpos < std:: char_traits < wchar_t > :: state_type >
std::u8streampos std:: fpos < std:: char_traits < char8_t > :: state_type >
std::u16streampos std:: fpos < std:: char_traits < char16_t > :: state_type >
std::u32streampos std:: fpos < std:: char_traits < char32_t > :: state_type >
De plus, pour chaque modèle de classe std::basic_ T déclaré dans cet en-tête, std:: T et std::w T sont déclarés comme synonymes de std::basic_ T <char> et std::basic_ T <wchar_t> respectivement.

Synopsis 

namespace std {
  template<class CharT> struct char_traits;
  template<> struct char_traits<char>;
  template<> struct char_traits<char8_t>;
  template<> struct char_traits<char16_t>;
  template<> struct char_traits<char32_t>;
  template<> struct char_traits<wchar_t>;
  template<class T> class allocator;
  template<class CharT, class Traits = char_traits<CharT>>
    class basic_ios;
  template<class CharT, class Traits = char_traits<CharT>>
    class basic_streambuf;
  template<class CharT, class Traits = char_traits<CharT>>
    class basic_istream;
  template<class CharT, class Traits = char_traits<CharT>>
    class basic_ostream;
  template<class CharT, class Traits = char_traits<CharT>>
    class basic_iostream;
  template<class CharT, class Traits = char_traits<CharT>,
           class Allocator = allocator<CharT>>
    class basic_stringbuf;
  template<class CharT, class Traits = char_traits<CharT>,
           class Allocator = allocator<CharT>>
    class basic_istringstream;
  template<class CharT, class Traits = char_traits<CharT>,
           class Allocator = allocator<CharT>>
    class basic_ostringstream;
  template<class CharT, class Traits = char_traits<CharT>,
           class Allocator = allocator<CharT>>
    class basic_stringstream;
  template<class CharT, class Traits = char_traits<CharT>>
    class basic_filebuf;
  template<class CharT, class Traits = char_traits<CharT>>
    class basic_ifstream;
  template<class CharT, class Traits = char_traits<CharT>>
    class basic_ofstream;
  template<class CharT, class Traits = char_traits<CharT>>
    class basic_fstream;
  template<class CharT, class Traits = char_traits<CharT>,
           class Allocator = allocator<CharT>>
    class basic_syncbuf;
  template<class CharT, class Traits = char_traits<CharT>,
           class Allocator = allocator<CharT>>
    class basic_osyncstream;
  template<class CharT, class Traits = char_traits<CharT>>
    class basic_spanbuf;
  template<class CharT, class Traits = char_traits<CharT>>
    class basic_ispanstream;
  template<class CharT, class Traits = char_traits<CharT>>
    class basic_ospanstream;
  template<class CharT, class Traits = char_traits<CharT>>
    class basic_spanstream;
  template<class CharT, class Traits = char_traits<CharT>>
    class istreambuf_iterator;
  template<class CharT, class Traits = char_traits<CharT>>
    class ostreambuf_iterator;
  using ios  = basic_ios<char>;
  using wios = basic_ios<wchar_t>;
  using streambuf = basic_streambuf<char>;
  using istream   = basic_istream<char>;
  using ostream   = basic_ostream<char>;
  using iostream  = basic_iostream<char>;
  using stringbuf     = basic_stringbuf<char>;
  using istringstream = basic_istringstream<char>;
  using ostringstream = basic_ostringstream<char>;
  using stringstream  = basic_stringstream<char>;
  using filebuf  = basic_filebuf<char>;
  using ifstream = basic_ifstream<char>;
  using ofstream = basic_ofstream<char>;
  using fstream  = basic_fstream<char>;
  using syncbuf     = basic_syncbuf<char>;
  using osyncstream = basic_osyncstream<char>;
  using spanbuf     = basic_spanbuf<char>;
  using ispanstream = basic_ispanstream<char>;
  using ospanstream = basic_ospanstream<char>;
  using spanstream  = basic_spanstream<char>;
  using wstreambuf = basic_streambuf<wchar_t>;
  using wistream   = basic_istream<wchar_t>;
  using wostream   = basic_ostream<wchar_t>;
  using wiostream  = basic_iostream<wchar_t>;
  using wstringbuf     = basic_stringbuf<wchar_t>;
  using wistringstream = basic_istringstream<wchar_t>;
  using wostringstream = basic_ostringstream<wchar_t>;
  using wstringstream  = basic_stringstream<wchar_t>;
  using wfilebuf  = basic_filebuf<wchar_t>;
  using wifstream = basic_ifstream<wchar_t>;
  using wofstream = basic_ofstream<wchar_t>;
  using wfstream  = basic_fstream<wchar_t>;
  using wsyncbuf     = basic_syncbuf<wchar_t>;
  using wosyncstream = basic_osyncstream<wchar_t>;
  using wspanbuf     = basic_spanbuf<wchar_t>;
  using wispanstream = basic_ispanstream<wchar_t>;
  using wospanstream = basic_ospanstream<wchar_t>;
  using wspanstream  = basic_spanstream<wchar_t>;
  template<class State> class fpos;
  using streampos = fpos<char_traits<char>::state_type>;
  using wstreampos = fpos<char_traits<wchar_t>::state_type>;
  using u8streampos = fpos<char_traits<char8_t>::state_type>;
  using u16streampos = fpos<char_traits<char16_t>::state_type>;
  using u32streampos = fpos<char_traits<char32_t>::state_type>;
}
// obsolète
namespace std {
  class strstreambuf;
  class istrstream;
  class ostrstream;
  class strstream;
}