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) |
| 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
#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);
};
Please login to continue.