Standard library header <ios>

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Execution support library (C++26)

Technical specifications

Symbols index

External libraries

 

Standard library headers

Language support <cfloat> <climits> <compare> (C++20) <coroutine> (C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint> (C++11) <cstdlib> <exception> <initializer_list> (C++11)    <limits> <new> <source_location> (C++20) <stdfloat> (C++23) <typeinfo> <version> (C++20) Concepts <concepts> (C++20) Diagnostics <cassert> <cerrno> <debugging> (C++26) <stacktrace> (C++23) <stdexcept> <system_error> (C++11) Memory management <memory> <memory_resource> (C++17) <scoped_allocator> (C++11) Metaprogramming <type_traits> (C++11) <ratio> (C++11)

General utilities <any> (C++17) <bitset> <bit> (C++20) <charconv> (C++17) <expected> (C++23) <format> (C++20) <functional> <optional> (C++17) <tuple> (C++11) <typeindex> (C++11) <utility> <variant> (C++17) Containers <array> (C++11) <deque> <flat_map> (C++23) <flat_set> (C++23) <forward_list> (C++11) <inplace_vector> (C++26)    <list> <map> <mdspan> (C++23) <queue> <set> <span> (C++20) <stack> <unordered_map> (C++11) <unordered_set> (C++11) <vector> Iterators <iterator> Ranges <generator> (C++23) <ranges> (C++20)

Algorithms <algorithm> <numeric> Strings <cctype> <cstring> <cuchar> (C++11) <cwchar> <cwctype> <string_view> (C++17) <string> Text processing <clocale> <codecvt> (C++11/17/26*) <locale> <regex> (C++11) <text_encoding> (C++26)    Numerics <cfenv> (C++11) <cmath> <complex> <linalg> (C++26) <numbers> (C++20) <random> (C++11) <valarray> Time <chrono> (C++11) <ctime> C compatibility <ccomplex> (C++11/17/20*) <ciso646> (until C++20) <cstdalign> (C++11/17/20*) <cstdbool> (C++11/17/20*) <ctgmath> (C++11/17/20*)

Input/output <cinttypes> (C++11) <cstdio> <filesystem> (C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print> (C++23) <spanstream> (C++23) <sstream> <streambuf> <strstream> (C++98/26*) <syncstream> (C++20) Concurrency support <atomic> (C++11) <barrier> (C++20) <condition_variable> (C++11) <future> (C++11) <hazard_pointer> (C++26) <latch> (C++20) <mutex> (C++11) <rcu> (C++26) <semaphore> (C++20) <shared_mutex> (C++14) <stdatomic.h> (C++23) <stop_token> (C++20) <thread> (C++11) Execution support <execution> (C++17)

 

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)
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 specialization)
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
iostream_category (C++11)	identifies the iostream error category (function)
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)
boolalphanoboolalpha	switches between textual and numeric representation of booleans (function)
showbasenoshowbase	controls whether prefix is used to indicate numeric base (function)
showpointnoshowpoint	controls whether decimal point is always included in floating-point representation (function)
showposnoshowpos	controls whether the + sign used with non-negative numbers (function)
skipwsnoskipws	controls whether leading whitespace is skipped on input (function)
uppercasenouppercase	controls whether uppercase characters are used with some output formats (function)
unitbufnounitbuf	controls whether output is flushed after each operation (function)
internalleftright	sets the placement of fill characters (function)
dechexoct	changes the base used for integer I/O (function)
fixedscientifichexfloatdefaultfloat (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);
};