# 标准库头文件 <iosfwd>

< cpp‎ | header

此头文件含有输入/输出库的前置声明。

### 前置声明
定义于头文件 `<string>`
std::char_traits | 描述字符类型的性质的类模板 (类模板)
std::char_traits<char> | (类模板特化)
std::char_traits<wchar_t> | (类模板特化)
std::char_traits<char8_t> (C++20) | (类模板特化)
std::char_traits<char16_t> (C++11) | (类模板特化)
std::char_traits<char32_t> (C++11) | (类模板特化)
定义于头文件 `<memory>`
allocator | 默认的分配器 (类模板)
定义于头文件 `<ios>`
basic_ios | 管理任意流缓冲 (类模板)
fpos | 表示流或文件中的绝对位置 (类模板)
定义于头文件 `<streambuf>`
basic_streambuf | 抽象原生设备 (类模板)
定义于头文件 `<ostream>`
basic_ostream | 包装给定的抽象设备（std::basic_streambuf） 并提供高层输出接口 (类模板)
定义于头文件 `<istream>`
basic_istream | 包装给定的抽象设备（std::basic_streambuf） 并提供高层输入接口 (类模板)
basic_iostream | 包装给定的抽象设备（std::basic_streambuf） 并提供高层输入/输出接口 (类模板)
定义于头文件 `<fstream>`
basic_filebuf | 抽象原生文件设备 (类模板)
basic_ifstream | 实现高层文件流输入操作 (类模板)
basic_ofstream | 实现高层文件流输出操作 (类模板)
basic_fstream | 实现高层文件流输入/输出操作 (类模板)
定义于头文件 `<sstream>`
basic_stringbuf | 实现原生字符串设备 (类模板)
basic_istringstream | 实现高层字符串流输入操作 (类模板)
basic_ostringstream | 实现高层字符串流输出操作 (类模板)
basic_stringstream | 实现高层字符串流输入/输出操作 (类模板)
定义于头文件 `<syncstream>`
basic_syncbuf (C++20) | 同步输出设备的包装 (类模板)
basic_osyncstream (C++20) | 同步输出流的包装 (类模板)
定义于头文件 `<strstream>`
strstreambuf (C++98 中弃用) | 实现原生字符数组设备 (类)
istrstream (C++98 中弃用) | 实现字符数组输入操作 (类)
ostrstream (C++98 中弃用) | 实现字符数组输出操作 (类)
strstream (C++98 中弃用) | 实现字符数组输入/输出操作 (类)
### typedef 与特化
std::streampos | std::fpos<std::char_traits<char>::state_type>
std::wstreampos | std::fpos<std::char_traits<wchar_t>::state_type>
std::u8streampos | std::fpos<std::char_traits<char8_t>::state_type>
std::u16streampos | std::fpos<std::char_traits<char16_t>::state_type>
std::u32streampos | std::fpos<std::char_traits<char32_t>::state_type>
另外，对于每个声明于此头文件的类模板 `std::basic_T`，分别声明了 `std::T` 和 `std::wT` 为 `std::basic_T<char>` 和 `std::basic_T<wchar_t>` 的同义词。

### 概要

    namespace std {
      template<class CharT> struct char_traits;
      template<> struct char_traits<char>;
      template<> struct char_traits<char8_t>;
      template<> struct char_traits<char16_t>;
      template<> struct char_traits<char32_t>;
      template<> struct char_traits<wchar_t>;

      template<class T> class allocator;

      template<class CharT, class Traits = char_traits<CharT>>
        class basic_ios;
      template<class CharT, class Traits = char_traits<CharT>>
        class basic_streambuf;
      template<class CharT, class Traits = char_traits<CharT>>
        class basic_istream;
      template<class CharT, class Traits = char_traits<CharT>>
        class basic_ostream;
      template<class CharT, class Traits = char_traits<CharT>>
        class basic_iostream;

      template<class CharT, class Traits = char_traits<CharT>>
               class Allocator = allocator<CharT>>
        class basic_stringbuf;
      template<class CharT, class Traits = char_traits<CharT>>
               class Allocator = allocator<CharT>>
        class basic_istringstream;
      template<class CharT, class Traits = char_traits<CharT>>
               class Allocator = allocator<CharT>>
        class basic_ostringstream;
      template<class CharT, class Traits = char_traits<CharT>>
               class Allocator = allocator<CharT>>
        class basic_stringstream;

      template<class CharT, class Traits = char_traits<CharT>>
        class basic_filebuf;
      template<class CharT, class Traits = char_traits<CharT>>
        class basic_ifstream;
      template<class CharT, class Traits = char_traits<CharT>>
        class basic_ofstream;
      template<class CharT, class Traits = char_traits<CharT>>
        class basic_fstream;

      template<class CharT, class Traits = char_traits<CharT>>
               class Allocator = allocator<CharT>>
        class basic_syncbuf;
      template<class CharT, class Traits = char_traits<CharT>>
               class Allocator = allocator<CharT>>
        class basic_osyncstream;

      template<class CharT, class Traits = char_traits<CharT>>
        class istreambuf_iterator;
      template<class CharT, class Traits = char_traits<CharT>>
        class ostreambuf_iterator;

      using ios  = basic_ios<char>;
      using wios = basic_ios<wchar_t>;

      using streambuf = basic_streambuf<char>;
      using istream   = basic_istream<char>;
      using ostream   = basic_ostream<char>;
      using iostream  = basic_iostream<char>;

      using stringbuf     = basic_stringbuf<char>;
      using istringstream = basic_istringstream<char>;
      using ostringstream = basic_ostringstream<char>;
      using stringstream  = basic_stringstream<char>;

      using filebuf  = basic_filebuf<char>;
      using ifstream = basic_ifstream<char>;
      using ofstream = basic_ofstream<char>;
      using fstream  = basic_fstream<char>;

      using syncbuf     = basic_syncbuf<char>;
      using osyncstream = basic_osyncstream<char>;

      using wstreambuf = basic_streambuf<wchar_t>;
      using wistream   = basic_istream<wchar_t>;
      using wostream   = basic_ostream<wchar_t>;
      using wiostream  = basic_iostream<wchar_t>;

      using wstringbuf     = basic_stringbuf<wchar_t>;
      using wistringstream = basic_istringstream<wchar_t>;
      using wostringstream = basic_ostringstream<wchar_t>;
      using wstringstream  = basic_stringstream<wchar_t>;

      using wfilebuf  = basic_filebuf<wchar_t>;
      using wifstream = basic_ifstream<wchar_t>;
      using wofstream = basic_ofstream<wchar_t>;
      using wfstream  = basic_fstream<wchar_t>;

      using wsyncbuf     = basic_syncbuf<wchar_t>;
      using wosyncstream = basic_osyncstream<wchar_t>;

      template<class State> class fpos;
      using streampos = fpos<char_traits<char>::state_type>;
      using wstreampos = fpos<char_traits<wchar_t>::state_type>;
      using u8streampos = fpos<char_traits<char8_t>::state_type>;
      using u16streampos = fpos<char_traits<char16_t>::state_type>;
      using u32streampos = fpos<char_traits<char32_t>::state_type>;
    }

    // 弃用
    namespace std {
      class strstreambuf;
      class istrstream;
      class ostrstream;
      class strstream;
    }