Namespaces
Variants
Views
Actions

Standard library header <ios>

From cppreference.com
< cpp‎ | header
Revision as of 18:26, 5 August 2013 by Cubbi (Talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)

This header is part of the Input/Output library.

Contents

Includes

<iosfwd>

Classes

manages formatting flags and input/output exceptions
(class)
manages an arbitrary stream buffer
(class template)
represents absolute position in a stream or a file
(class template)
(C++11)
the IO stream error codes
(enum) [edit]
identifies the iostream error category
(function) [edit]
extends the type trait std::is_error_code_enum to identify iostream error codes
(class template) [edit]

Typedefs and specializations

ios basic_ios<char>
wios basic_ios<wchar_t>
represents relative file/stream position (offset from fpos), sufficient to represent any file size
(typedef)
represents the number of characters transferred in an I/O operation or the size of an I/O buffer
(typedef)
streampos std::fpos<std::char_traits<char>::state_type>
u16streampos std::fpos<std::char_traits<char16_t>::state_type>
u32streampos std::fpos<std::char_traits<char32_t>::state_type>
wstreampos std::fpos<std::char_traits<wchar_t>::state_type>

Functions

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

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