MENU
Edit
In Place Editing Advanced Editing

ios

This header is part of the Input/Output library.

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)
(C++11)
 identifies the iostream error category
(function)
(C++11)
 extends the type trait std::is_error_code_enum to identify iostream error codes
(class template)

Typedefs

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)

Functions

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

Synopsis

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
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

1
2
3
4
5
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

1
2
3
4
5
6
7
class ios_base::Init {
 public:
    Init();
    ~Init();
 private:
    static int init_cnt; // exposition only
};

Class std::fpos

1
2
3
4
5
6
7
template <class stateT> class fpos {
 public:
    stateT state() const;
    void state(stateT);
 private;
    stateT st; // exposition only
};

Class std::basic_ios

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
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);
};
doc_CPP
doc_CPP
2025-01-10 15:47:30
Comments
Leave a Comment

Please login to continue.