Namespaces
Variants

Standard library header <ios>

From cppreference.net
C++
Standard library headers

Este encabezado es parte de la biblioteca de Entrada/Salida .

Contenidos

Includes

Declaraciones anticipadas de todas las clases en la biblioteca de entrada/salida

Clases

gestiona indicadores de formato y excepciones de entrada/salida
(clase)
gestiona un búfer de flujo arbitrario
(plantilla de clase)
std::ios std:: basic_ios < char > (definición de tipo)
std::wios std:: basic_ios < wchar_t > (typedef)
representa la posición absoluta en un flujo o archivo
(class template)
(C++11)
los códigos de error de flujo de E/S
(enum)
(C++11)
extiende el rasgo de tipo std::is_error_code_enum para identificar códigos de error de iostream
(especialización de plantilla de clase)
representa la posición relativa de archivo/flujo (desplazamiento desde fpos), suficiente para representar cualquier tamaño de archivo
(typedef)
representa el número de caracteres transferidos en una operación de E/S o el tamaño de un búfer de E/S
(typedef)

Funciones

(C++11)
identifica la categoría de error de iostream
(función)
(C++11)
construye un código de error de iostream
(función)
(C++11)
construye una condición de error de iostream
(función)
cambia entre la representación textual y numérica de booleanos
(función)
controla si se utiliza el prefijo para indicar la base numérica
(función)
controla si el punto decimal siempre se incluye en la representación de punto flotante
(función)
controla si el + signo se utiliza con números no negativos
(función)
controla si se omite el espacio en blanco inicial en la entrada
(función)
controla si se utilizan caracteres en mayúsculas con algunos formatos de salida
(función)
controla si la salida se vacía después de cada operación
(función)
establece la ubicación de los caracteres de relleno
(función)
cambia la base utilizada para E/S de enteros
(función)
(C++11) (C++11)
cambia el formato utilizado para E/S de punto flotante
(función)

Sinopsis 

#include <iosfwd>
namespace std {
  using streamoff  = /* definido por la implementación */;
  using streamsize = /* definido por la implementación */;
  template<class StateT> class fpos;
  class ios_base;
  template<class CharT, class Traits = char_traits<CharT>>
    class basic_ios;
  // manipuladores
  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);
  // campo de ajuste
  ios_base& internal   (ios_base& str);
  ios_base& left       (ios_base& str);
  ios_base& right      (ios_base& str);
  // campo base
  ios_base& dec        (ios_base& str);
  ios_base& hex        (ios_base& str);
  ios_base& oct        (ios_base& str);
  // campo flotante
  ios_base& fixed      (ios_base& str);
  ios_base& scientific (ios_base& str);
  ios_base& hexfloat   (ios_base& str);
  ios_base& defaultfloat(ios_base& str);
  // reporte de errores
  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;
}

Clase std::ios_base 

namespace std {
  class ios_base {
  public:
    class failure;              // ver descripción
    // fmtflags
    using fmtflags = /*bitmask-type-1*/;
    static constexpr fmtflags boolalpha = /* sin especificar */;
    static constexpr fmtflags dec = /* sin especificar */;
    static constexpr fmtflags fixed = /* sin especificar */;
    static constexpr fmtflags hex = /* sin especificar */;
    static constexpr fmtflags internal = /* sin especificar */;
    static constexpr fmtflags left = /* sin especificar */;
    static constexpr fmtflags oct = /* sin especificar */;
    static constexpr fmtflags right = /* sin especificar */;
    static constexpr fmtflags scientific = /* sin especificar */;
    static constexpr fmtflags showbase = /* sin especificar */;
    static constexpr fmtflags showpoint = /* sin especificar */;
    static constexpr fmtflags showpos = /* sin especificar */;
    static constexpr fmtflags skipws = /* sin especificar */;
    static constexpr fmtflags unitbuf = /* sin especificar */;
    static constexpr fmtflags uppercase = /* sin especificar */;
    static constexpr fmtflags adjustfield = /* ver descripción */;
    static constexpr fmtflags basefield = /* ver descripción */;
    static constexpr fmtflags floatfield = /* ver descripción */;
    // iostate
    using iostate = /*bitmask-type-2*/;
    static constexpr iostate badbit = /* sin especificar */;
    static constexpr iostate eofbit = /* sin especificar */;
    static constexpr iostate failbit = /* sin especificar */;
    static constexpr iostate goodbit = /* ver descripción */;
    // openmode
    using openmode = /*bitmask-type-3*/;
    static constexpr openmode app = /* sin especificar */;
    static constexpr openmode ate = /* sin especificar */;
    static constexpr openmode binary = /* sin especificar */;
    static constexpr openmode in = /* sin especificar */;
    static constexpr openmode out = /* sin especificar */;
    static constexpr openmode trunc = /* sin especificar */;
    static constexpr openmode noreplace = /* sin especificar */
    // seekdir
    using seekdir = /*bitmask-type-4*/;
    static constexpr seekdir beg = /* sin especificar */;
    static constexpr seekdir cur = /* sin especificar */;
    static constexpr seekdir end = /* sin especificar */;
    class Init;
    // estado de fmtflags
    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;
    // almacenamiento
    static int xalloc();
    long&  iword(int idx);
    void*& pword(int idx);
    // destructor
    virtual ~ios_base();
    // callbacks
    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;           // exposición solamente
    long*  iarray;              // exposición solamente
    void** parray;              // exposición solamente
  };
}

Clase 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);
  };
}

Clase 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;        // solo para exposición
  };
}

Plantilla de clase std::fpos 

namespace std {
  template<class StateT> class fpos {
  public:
    // miembros
    StateT state() const;
    void state(stateT);
  private;
    StateT st;                  // solo para exposición
  };
}

Plantilla de clase 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;
    // funciones de banderas
    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);
    // constructor/destructor
    explicit basic_ios(basic_streambuf<CharT, Traits>* sb);
    virtual ~basic_ios();
    // miembros
    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);
  };
}

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 35 C++98 los prototipos de unitbuf y nounitbuf faltaban en la sinopsis añadidos
LWG 78 C++98 el tipo del parámetro fn de ios_base::register_callback
en la sinopsis estaba mal especificado como event_call_back 		corregido a
event_callback