# Standard library header <ios>

From cppreference.com
< cpp‎ | header

This header is part of the Input/Output library.

### Includes

`<iosfwd>`

### Classes

ios_base | manages formatting flags and input/output exceptions (class)
basic_ios | manages an arbitrary stream buffer (class template)
fpos | represents absolute position in a stream or a file (class template)
io_errc (C++11) | the IO stream error codes (enum)
iostream_category (C++11) | identifies the iostream error category (function)
is_error_code_enum<std::io_errc> (C++11) | extends the type trait std::is_error_code_enum to identify iostream error codes (class template)

### Typedefs

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

### Functions

make_error_code(std::io_errc) (C++11) | constructs an iostream error code (function)
make_error_condition(std::io_errc) (C++11) | constructs an iostream error_condition (function)
boolalpha noboolalpha | switches between textual and numeric representation of booleans (function)
showbase noshowbase | controls whether prefix is used to indicate numeric base (function)
showpoint noshowpoint | controls whether decimal point is always included in floating-point representation (function)
showpos noshowpos | controls whether the `+` sign used with non-negative numbers (function)
skipws noskipws | controls whether leading whitespace is skipped on input (function)
uppercase nouppercase | controls whether uppercase characters are used with some output formats (function)
unitbuf nounitbuf | controls whether output is flushed after each operation (function)
internal left right | sets the placement of fill characters (function)
dec hex oct | changes the base used for integer I/O (function)
fixed scientific hexfloat defaultfloat (C++11)(C++11) | changes formatting used for floating-point I/O (function)

### Synopsis

    #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 {
     public:
        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 {
            erase_event,
            imbue_event,
            copyfmt_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);

     protected:
        ios_base();

     private:
        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 {
     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);
    };

#### Class std::ios_base::Init

    class ios_base::Init {
     public:
        Init();
        ~Init();
     private:
        static int init_cnt; // exposition only
    };

#### Class std::fpos

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

#### Class std::basic_ios

    template <class charT, class traits = char_traits<charT> >
    class basic_ios : public ios_base {
     public:
        // 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;

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

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/header/ios&oldid=72066"