標準ライブラリヘッダ <ios>

 

C++

言語

標準ライブラリヘッダ

フリースタンディング処理系とホスト処理系

名前付き要件

言語サポートライブラリ

コンセプトライブラリ (C++20)

診断ライブラリ

ユーティリティライブラリ

文字列ライブラリ

コンテナライブラリ

イテレータライブラリ

範囲ライブラリ (C++20)

アルゴリズムライブラリ

数値演算ライブラリ

ローカライゼーションライブラリ

入出力ライブラリ

ファイルシステムライブラリ (C++17)

正規表現ライブラリ (C++11)

アトミック操作ライブラリ (C++11)

スレッドサポートライブラリ (C++11)

技術仕様書

 

標準ライブラリヘッダ

言語サポート
<cstddef> <cstdlib> <version> <limits> <climits>	<cfloat> <cstdint> <new> <typeinfo>	<source_location> <exception> <initializer_list> <compare>	<coroutine> <csignal> <csetjmp> <cstdarg>
コンセプト
<concepts>
診断
<stdexcept>	<cassert>	<cerrno>	<system_error>
汎用ユーティリティ
<utility> <memory> <memory_resource> <scoped_allocator>	<bitset> <tuple> <optional> <any>	<variant> <type_traits> <ratio> <chrono>	<typeindex> <functional> <ctime>
文字列
<string> <string_view> <cstring>	<charconv> <format>	<cctype> <cwctype>	<cwchar> <cuchar>
ローカライゼーション
<locale>	<codecvt>	<clocale>
コンテナ
<span> <array> <vector>	<deque> <forward_list> <list>	<map> <set> <queue>	<unordered_map> <unordered_set> <stack>
イテレータ
<iterator>
範囲
<ranges>
アルゴリズム
<algorithm>	<execution>
数値演算
<complex> <random>	<valarray> <numeric>	<bit> <numbers>	<cfenv> <cmath>
入出力
<iosfwd> <ios> <iomanip> <streambuf>	<istream> <ostream> <iostream>	<sstream> <spanstream> <fstream> <syncstream>	<cstdio> <cinttypes> <strstream>
正規表現
<regex>
ファイルシステムサポート
<filesystem>
スレッドサポート
<thread> <atomic> <mutex>	<shared_mutex> <condition_variable> <future>	<stop_token> <semaphore>	<latch> <barrier>
C互換
<ciso646> <cstdalign>	<cstdbool> <ccomplex>	<ctgmath> <stdatomic.h>

 

このヘッダは入出力ライブラリの一部です。

インクルード
<iosfwd>	入出力ライブラリのすべてのクラスの前方宣言
クラス
ios_base	フォーマットフラグと入出力例外を管理します (クラス)
basic_ios	任意のストリームバッファを管理します (クラステンプレート)
fpos	ストリームまたはファイル内の絶対位置を表します (クラステンプレート)
io_errc (C++11)	iostream のエラーコード (列挙)
is_error_code_enum<std::io_errc> (C++11)	入出力ストリームのエラーコードを識別するために型特性 std::is_error_code_enum を拡張します (クラステンプレートの特殊化)
streamoff	ファイルまたはストリームの相対位置 (fpos からのオフセット) を表します。 任意のファイルサイズを表現するのに十分な大きさです (typedef)
streamsize	入出力操作で転送された文字数または入出力バッファのサイズを表します (typedef)
関数
iostream_category (C++11)	入出力ストリームのエラーカテゴリを識別します (関数)
make_error_code(std::io_errc) (C++11)	入出力ストリームのエラーコードを構築します (関数)
make_error_condition(std::io_errc) (C++11)	入出力ストリームの error_condition を構築します (関数)
boolalphanoboolalpha	ブーリアンの表現をテキストと数値の間で切り替えます (関数)
showbasenoshowbase	数値の基数を表すために接頭辞を使用するかどうか制御します (関数)
showpointnoshowpoint	浮動小数点の表現に常に小数点が含まれるかどうか制御します (関数)
showposnoshowpos	非負の数値で + 記号を使用するかどうか制御します (関数)
skipwsnoskipws	入力時に先行するホワイトスペースをスキップするかどうか制御します (関数)
uppercasenouppercase	いくつかの出力書式で大文字を使用するかどうか制御します (関数)
unitbufnounitbuf	各操作ごとに出力をフラッシュするかどうか制御します (関数)
internalleftright	フィル文字の配置を設定します (関数)
dechexoct	整数の入出力に使用される基数を変更します (関数)
fixedscientifichexfloatdefaultfloat (C++11)(C++11)	浮動小数点の入出力に使用される書式を変更します (関数)

概要

#include <iosfwd>

namespace std {
  using streamoff  = /* implementation-defined */;
  using streamsize = /* implementation-defined */;
  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);

  // adjustfield
  ios_base& internal   (ios_base& str);
  ios_base& left       (ios_base& str);
  ios_base& right      (ios_base& str);

  // basefield
  ios_base& dec        (ios_base& str);
  ios_base& hex        (ios_base& str);
  ios_base& oct        (ios_base& str);

  // floatfield
  ios_base& fixed      (ios_base& str);
  ios_base& scientific (ios_base& str);
  ios_base& hexfloat   (ios_base& str);
  ios_base& defaultfloat(ios_base& str);

  // error reporting
  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) noexcept;
  error_condition make_error_condition(io_errc e) noexcept;
  const error_category& iostream_category() noexcept;
}

クラス std::ios_base

namespace std {
  class ios_base {
  public:
    class failure;              // see description

    // fmtflags
    using fmtflags = /*bitmask-type-1*/;
    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 = /* see description */;
    static constexpr fmtflags basefield = /* see description */;
    static constexpr fmtflags floatfield = /* see description */;

    // iostate
    using iostate = /*bitmask-type-2*/;
    static constexpr iostate badbit = /* unspecified */;
    static constexpr iostate eofbit = /* unspecified */;
    static constexpr iostate failbit = /* unspecified */;
    static constexpr iostate goodbit = /* see description */;

    // openmode
    using openmode = /*bitmask-type-3*/;
    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
    using seekdir = /*bitmask-type-4*/;
    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 idx);
    void*& pword(int idx);

    // destructor
    virtual ~ios_base();

    // callbacks
    enum event { erase_event, imbue_event, copyfmt_event };
    using event_callback = void (*)(event, ios_base&, int idx);
    void register_callback(event_callback fn, int idx);

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

クラス std::ios_base::failure

namespace std {
  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);
  };
}

クラス std::ios_base::Init

namespace std {
  class ios_base::Init {
  public:
    Init();
    Init(const Init&) = default;
    ~Init();
    Init& operator=(const Init&) = default;
  private:
    static int init_cnt;        // exposition only
  };
}

クラステンプレート std::fpos

namespace std {
  template<class StateT> class fpos {
  public:
    // members
    StateT state() const;
    void state(stateT);
  private;
    StateT st;                  // exposition only
  };
}

クラステンプレート std::basic_ios

namespace std {
  template<class CharT, class Traits = char_traits<CharT>>
  class basic_ios : public ios_base {
  public:
    using char_type   = CharT;
    using int_type    = typename Traits::int_type;
    using pos_type    = typename Traits::pos_type;
    using off_type    = typename Traits::off_type;
    using traits_type = Traits;

    // flags functions
    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);

  };
}