Namespaces
Variants

Standard library header <ios>

From cppreference.net
C++
Standard library headers

Cet en-tête fait partie de la bibliothèque d'Entrée/Sortie .

Table des matières

Includes

Déclarations anticipées de toutes les classes de la bibliothèque d'entrée/sortie

Classes

gère les indicateurs de formatage et les exceptions d'entrée/sortie
(classe)
gère un tampon de flux arbitraire
(modèle de classe)
std::ios std:: basic_ios < char > (typedef)
std::wios std:: basic_ios < wchar_t > (typedef)
représente une position absolue dans un flux ou un fichier
(modèle de classe)
(C++11)
les codes d'erreur des flux d'E/S
(enum)
(C++11)
étend le trait de type std::is_error_code_enum pour identifier les codes d'erreur des flux
(spécialisation de modèle de classe)
représente la position relative du fichier/flux (décalage depuis fpos), suffisante pour représenter n'importe quelle taille de fichier
(typedef)
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)

Fonctions

(C++11)
identifie la catégorie d'erreur des iostream
(fonction)
(C++11)
construit un code d'erreur iostream
(fonction)
(C++11)
construit une condition d'erreur iostream
(fonction)
bascule entre la représentation textuelle et numérique des booléens
(fonction)
contrôle si le préfixe est utilisé pour indiquer la base numérique
(fonction)
contrôle si la virgule décimale est toujours incluse dans la représentation des nombres à virgule flottante
(fonction)
contrôle si le signe + est utilisé avec les nombres non négatifs
(fonction)
contrôle si les espaces blancs initiaux sont ignorés en entrée
(fonction)
contrôle si les caractères majuscules sont utilisés avec certains formats de sortie
(fonction)
contrôle si la sortie est vidée après chaque opération
(fonction)
définit le positionnement des caractères de remplissage
(fonction)
modifie la base utilisée pour les E/S d'entiers
(fonction)
(C++11) (C++11)
modifie le formatage utilisé pour les E/S en virgule flottante
(fonction)

Synopsis 

#include <iosfwd>
namespace std {
  using streamoff  = /* implementation-defined */;
  using streamsize = /* implementation-defined */;
  template<class StateT> class fpos;
  class ios_base;
  template<class CharT, class Traits = char_traits<CharT>>
    class basic_ios;
  // manipulateurs
  ios_base& boolalpha  (ios_base& str);
  ios_base& noboolalpha(ios_base& str);
  ios_base& showbase   (ios_base& str);
  ios_base& noshowbase (ios_base& str);
  ios_base& showpoint  (ios_base& str);
  ios_base& noshowpoint(ios_base& str);
  ios_base& showpos    (ios_base& str);
  ios_base& noshowpos  (ios_base& str);
  ios_base& skipws     (ios_base& str);
  ios_base& noskipws   (ios_base& str);
  ios_base& uppercase  (ios_base& str);
  ios_base& nouppercase(ios_base& str);
  ios_base& unitbuf    (ios_base& str);
  ios_base& nounitbuf  (ios_base& str);
  // champ d'ajustement
  ios_base& internal   (ios_base& str);
  ios_base& left       (ios_base& str);
  ios_base& right      (ios_base& str);
  // champ de base
  ios_base& dec        (ios_base& str);
  ios_base& hex        (ios_base& str);
  ios_base& oct        (ios_base& str);
  // champ de virgule flottante
  ios_base& fixed      (ios_base& str);
  ios_base& scientific (ios_base& str);
  ios_base& hexfloat   (ios_base& str);
  ios_base& defaultfloat(ios_base& str);
  // rapport d'erreurs
  enum class io_errc {
    stream = 1
  };
  template<> struct is_error_code_enum<io_errc> : public true_type { };
  error_code make_error_code(io_errc e) noexcept;
  error_condition make_error_condition(io_errc e) noexcept;
  const error_category& iostream_category() noexcept;
}

Classe std::ios_base 

namespace std {
  class ios_base {
  public:
    class failure;              // voir description
    // indicateurs de formatage
    using fmtflags = /*bitmask-type-1*/;
    static constexpr fmtflags boolalpha = /* non spécifié */;
    static constexpr fmtflags dec = /* non spécifié */;
    static constexpr fmtflags fixed = /* non spécifié */;
    static constexpr fmtflags hex = /* non spécifié */;
    static constexpr fmtflags internal = /* non spécifié */;
    static constexpr fmtflags left = /* non spécifié */;
    static constexpr fmtflags oct = /* non spécifié */;
    static constexpr fmtflags right = /* non spécifié */;
    static constexpr fmtflags scientific = /* non spécifié */;
    static constexpr fmtflags showbase = /* non spécifié */;
    static constexpr fmtflags showpoint = /* non spécifié */;
    static constexpr fmtflags showpos = /* non spécifié */;
    static constexpr fmtflags skipws = /* non spécifié */;
    static constexpr fmtflags unitbuf = /* non spécifié */;
    static constexpr fmtflags uppercase = /* non spécifié */;
    static constexpr fmtflags adjustfield = /* voir description */;
    static constexpr fmtflags basefield = /* voir description */;
    static constexpr fmtflags floatfield = /* voir description */;
    // iostate
    using iostate = /*bitmask-type-2*/;
    static constexpr iostate badbit = /* non spécifié */;
    static constexpr iostate eofbit = /* non spécifié */;
    static constexpr iostate failbit = /* non spécifié */;
    static constexpr iostate goodbit = /* voir description */;
    // mode d'ouverture
    using openmode = /*bitmask-type-3*/;
    static constexpr openmode app = /* non spécifié */;
    static constexpr openmode ate = /* non spécifié */;
    static constexpr openmode binary = /* non spécifié */;
    static constexpr openmode in = /* non spécifié */;
    static constexpr openmode out = /* non spécifié */;
    static constexpr openmode trunc = /* non spécifié */;
    static constexpr openmode noreplace = /* non spécifié */
    // seekdir
    using seekdir = /*bitmask-type-4*/;
    static constexpr seekdir beg = /* non spécifié */;
    static constexpr seekdir cur = /* non spécifié */;
    static constexpr seekdir end = /* non spécifié */;
    class Init;
    // État des indicateurs de format
    fmtflags flags() const;
    fmtflags flags(fmtflags fmtfl);
    fmtflags setf(fmtflags fmtfl);
    fmtflags setf(fmtflags fmtfl, fmtflags mask);
    void unsetf(fmtflags mask);
    streamsize precision() const;
    streamsize precision(streamsize prec);
    streamsize width() const;
    streamsize width(streamsize wide);
    // locales
    locale imbue(const locale& loc);
    locale getloc() const;
    // stockage
    static int xalloc();
    long&  iword(int idx);
    void*& pword(int idx);
    // destructeur
    virtual ~ios_base();
    // rappels
    enum event { erase_event, imbue_event, copyfmt_event };
    using event_callback = void (*)(event, ios_base&, int idx);
    void register_callback(event_callback fn, int idx);
    ios_base(const ios_base&) = delete;
    ios_base& operator=(const ios_base&) = delete;
    static bool sync_with_stdio(bool sync = true);
  protected:
    ios_base();
  private:
    static int index;           // exposition uniquement
    long*  iarray;              // exposition uniquement
    void** parray;              // exposition uniquement
  };
}

Classe std::ios_base::failure 

namespace std {
  class ios_base::failure : public system_error {
  public:
    explicit failure(const string& msg, const error_code& ec = io_errc::stream);
    explicit failure(const char* msg, const error_code& ec = io_errc::stream);
  };
}

Classe std::ios_base::Init 

namespace std {
  class ios_base::Init {
  public:
    Init();
    Init(const Init&) = default;
    ~Init();
    Init& operator=(const Init&) = default;
  private:
    static int init_cnt;        // exposition uniquement
  };
}

Modèle de classe std::fpos 

namespace std {
  template<class StateT> class fpos {
  public:
    // membres
    StateT state() const;
    void state(stateT);
  private;
    StateT st;                  // exposition uniquement
  };
}

Modèle de classe std::basic_ios 

namespace std {
  template<class CharT, class Traits = char_traits<CharT>>
  class basic_ios : public ios_base {
  public:
    using char_type   = CharT;
    using int_type    = typename Traits::int_type;
    using pos_type    = typename Traits::pos_type;
    using off_type    = typename Traits::off_type;
    using traits_type = Traits;
    // fonctions de drapeaux
    explicit operator bool() const;
    bool operator!() const;
    iostate rdstate() const;
    void clear(iostate state = goodbit);
    void setstate(iostate state);
    bool good() const;
    bool eof()  const;
    bool fail() const;
    bool bad()  const;
    iostate exceptions() const;
    void exceptions(iostate except);
    // constructeur/destructeur
    explicit basic_ios(basic_streambuf<CharT, Traits>* sb);
    virtual ~basic_ios();
    // membres
    basic_ostream<CharT, Traits>* tie() const;
    basic_ostream<CharT, Traits>* tie(basic_ostream<CharT, Traits>* tiestr);
    basic_streambuf<CharT, Traits>* rdbuf() const;
    basic_streambuf<CharT, Traits>* rdbuf(basic_streambuf<CharT, Traits>* sb);
    basic_ios& copyfmt(const basic_ios& rhs);
    char_type fill() const;
    char_type fill(char_type ch);
    locale imbue(const locale& loc);
    char      narrow(char_type c, char dfault) const;
    char_type widen(char c) const;
    basic_ios(const basic_ios&) = delete;
    basic_ios& operator=(const basic_ios&) = delete;
  protected:
    basic_ios();
    void init(basic_streambuf<CharT, Traits>* sb);
    void move(basic_ios& rhs);
    void move(basic_ios&& rhs);
    void swap(basic_ios& rhs) noexcept;
    void set_rdbuf(basic_streambuf<CharT, Traits>* sb);
  };
}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Applicable à Comportement publié Comportement corrigé
LWG 35 C++98 les prototypes de unitbuf et nounitbuf étaient manquants dans le synopsis ajoutés
LWG 78 C++98 le type du paramètre fn de ios_base::register_callback
dans le synopsis était mal spécifié comme event_call_back 		corrigé en
event_callback