Standard library header <ios>

< cpp‎ | header

This header is part of the Input/Output library.




manages formatting flags and input/output exceptions
manages an arbitrary stream buffer
(class template)
represents absolute position in a stream or a file
(class template)
the IO stream error codes
extends the type trait std::is_error_code_enum to identify iostream error codes
(class template)


represents relative file/stream position (offset from fpos), sufficient to represent any file size
represents the number of characters transferred in an I/O operation or the size of an I/O buffer


identifies the iostream error category
constructs an iostream error code
constructs an iostream error_condition
switches between textual and numeric representation of booleans
controls whether prefix is used to indicate numeric base
controls whether decimal point is always included in floating-point representation
controls whether the + sign used with non-negative numbers
controls whether leading whitespace is skipped on input
controls whether uppercase characters are used with some output formats
controls whether output is flushed after each operation
sets the placement of fill characters
changes the base used for integer I/O
changes formatting used for floating-point I/O


#include <iosfwd>
namespace std {
    typedef /*implementation-defined*/ streamoff;
    typedef /*implementation-defined*/ streamsize;
    template <class stateT> class fpos;
    class ios_base;
    template <class charT, class traits = char_traits<charT> >
        class basic_ios;
    // manipulators:
    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);
    ios_base& internal (ios_base& str);
    ios_base& left (ios_base& str);
    ios_base& right (ios_base& str);
    ios_base& dec (ios_base& str);
    ios_base& hex (ios_base& str);
    ios_base& oct (ios_base& str);
    ios_base& fixed (ios_base& str);
    ios_base& scientific (ios_base& str);
    ios_base& hexfloat (ios_base& str);
    ios_base& defaultfloat(ios_base& str);
    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);
    error_condition make_error_condition(io_errc e);
    const error_category& iostream_category();

Class std::ios_base

class ios_base {
    class failure;
    // fmtflags
    typedef /*bitmask-type-1*/ fmtflags;
    static constexpr fmtflags boolalpha = /*unspecified*/;
    static constexpr fmtflags dec = /*unspecified*/;
    static constexpr fmtflags fixed = /*unspecified*/;
    static constexpr fmtflags hex = /*unspecified*/;
    static constexpr fmtflags internal = /*unspecified*/;
    static constexpr fmtflags left = /*unspecified*/;
    static constexpr fmtflags oct = /*unspecified*/;
    static constexpr fmtflags right = /*unspecified*/;
    static constexpr fmtflags scientific = /*unspecified*/;
    static constexpr fmtflags showbase = /*unspecified*/;
    static constexpr fmtflags showpoint = /*unspecified*/;
    static constexpr fmtflags showpos = /*unspecified*/;
    static constexpr fmtflags skipws = /*unspecified*/;
    static constexpr fmtflags unitbuf = /*unspecified*/;
    static constexpr fmtflags uppercase = /*unspecified*/;
    static constexpr fmtflags adjustfield = /*left|right|internal*/ ;
    static constexpr fmtflags basefield = /*dec|oct|hex*/ ;
    static constexpr fmtflags floatfield = /*scientific|fixed*/ ;
    // iostate
    typedef /*bitmask-type-2*/ iostate;
    static constexpr iostate badbit = /*unspecified*/;
    static constexpr iostate eofbit = /*unspecified*/;
    static constexpr iostate failbit = /*unspecified*/;
    static constexpr iostate goodbit = /*0*/ ;
    // openmode
    typedef /*bitmask-type-3*/ openmode;
    static constexpr openmode app = /*unspecified*/;
    static constexpr openmode ate = /*unspecified*/;
    static constexpr openmode binary = /*unspecified*/;
    static constexpr openmode in = /*unspecified*/;
    static constexpr openmode out = /*unspecified*/;
    static constexpr openmode trunc = /*unspecified*/;
    // seekdir
    typedef /*bitmask-type-4*/ seekdir;
    static constexpr seekdir beg = /*unspecified*/;
    static constexpr seekdir cur = /*unspecified*/;
    static constexpr seekdir end = /*unspecified*/;
    class Init;
    // fmtflags state:
    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;
    // storage:
    static int xalloc();
    long& iword(int index);
    void*& pword(int index);
    // destructor
    virtual ~ios_base();
    // callbacks;
    enum event {
    typedef void (*event_callback)(event, ios_base&, int index);
    void register_callback(event_callback fn, int index);
    ios_base(const ios_base&) = delete;
    ios_base& operator=(const ios_base&) = delete;
    static bool sync_with_stdio(bool sync = true);
    static int index; // exposition only
    long* iarray; // exposition only
    void** parray; // exposition only

Class std::ios_base::failure

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

Class std::ios_base::Init

class ios_base::Init {
    static int init_cnt; // exposition only

Class std::fpos

template <class stateT> class fpos {
    stateT state() const;
    void state(stateT);
    stateT st; // exposition only

Class std::basic_ios

template <class charT, class traits = char_traits<charT> >
class basic_ios : public ios_base {
    // types:
    typedef charT char_type;
    typedef typename traits::int_type int_type;
    typedef typename traits::pos_type pos_type;
    typedef typename traits::off_type off_type;
    typedef traits traits_type;
    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();
    // Members:
    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;
    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);