Standard library header <ios>
From cppreference.com
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) |
| 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) |
identifies the iostream error category (function) |
| 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); };