标准库头文件 <fstream>

 

C++

语言

标准库头文件

自立与有宿主实现

具名要求

语言支持库

概念库 (C++20)

诊断库

工具库

字符串库

容器库

迭代器库

范围库 (C++20)

算法库

数值库

输入/输出库

本地化库

正则表达式库 (C++11)

原子操作库 (C++11)

线程支持库 (C++11)

文件系统库 (C++17)

技术规范

 

标准库头文件

语言支持
<cstddef> <limits> <climits> <coroutine>	<cfloat> <cstdint> <new> <source_location>	<typeinfo> <exception> <initializer_list> <version>	<csignal> <csetjmp> <cstdarg>
概念
<concepts>
诊断
<stdexcept>	<cassert>	<cerrno>	<system_error>
通用工具
<utility> <memory> <memory_resource> <scoped_allocator>     <compare>	<bitset> <tuple> <optional> <any> <variant>	<type_traits> <ratio> <chrono> <typeindex> <functional>	<ctime> <cstdlib>
字符串
<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> <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>

 

此头文件是输入/输出库的一部分。

类
basic_filebuf	抽象原生文件设备 (类模板)
basic_ifstream	实现高层文件流输入操作 (类模板)
basic_ofstream	实现高层文件流输出操作 (类模板)
basic_fstream	实现高层文件流输入/输出操作 (类模板)
typedef
filebuf	basic_filebuf<char>
wfilebuf	basic_filebuf<wchar_t>
ifstream	basic_ifstream<char>
wifstream	basic_ifstream<wchar_t>
ofstream	basic_ofstream<char>
wofstream	basic_ofstream<wchar_t>
fstream	basic_fstream<char>
wfstream	basic_fstream<wchar_t>
函数
std::swap(std::basic_filebuf) (C++11)	特化 std::swap 算法 (函数模板)
std::swap(std::basic_ifstream) (C++11)	特化 std::swap 算法 (函数模板)
std::swap(std::basic_ofstream) (C++11)	特化 std::swap 算法 (函数模板)
std::swap(std::basic_fstream) (C++11)	特化 std::swap 算法 (函数模板)

概要

namespace std {
 
template <class charT, class traits = char_traits<charT> >
    class basic_filebuf;
typedef basic_filebuf<char> filebuf;
typedef basic_filebuf<wchar_t> wfilebuf;
template <class charT, class traits>
    void swap(basic_filebuf<charT, traits>& x,
              basic_filebuf<charT, traits>& y);
 
template <class charT, class traits = char_traits<charT> >
    class basic_ifstream;
typedef basic_ifstream<char> ifstream;
typedef basic_ifstream<wchar_t> wifstream;
template <class charT, class traits>
    void swap(basic_ifstream<charT, traits>& x,
              basic_ifstream<charT, traits>& y);
 
template <class charT, class traits = char_traits<charT> >
    class basic_ofstream;
typedef basic_ofstream<char> ofstream;
typedef basic_ofstream<wchar_t> wofstream;
template <class charT, class traits>
    void swap(basic_ofstream<charT, traits>& x,
              basic_ofstream<charT, traits>& y);
 
template <class charT, class traits = char_traits<charT> >
    class basic_fstream;
typedef basic_fstream<char> fstream;
typedef basic_fstream<wchar_t> wfstream;
template <class charT, class traits>
    void swap(basic_fstream<charT, traits>& x,
              basic_fstream<charT, traits>& y);
}

类 std::basic_filebuf

template <class charT, class traits = char_traits<charT> >
class basic_filebuf : public basic_streambuf<charT,traits> {
 public:
    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;
 
    // 构造函数/析构函数：
    basic_filebuf();
    basic_filebuf(const basic_filebuf& rhs) = delete;
    basic_filebuf(basic_filebuf&& rhs);
    virtual ~basic_filebuf();
 
    // 赋值/交换：
    basic_filebuf& operator=(const basic_filebuf& rhs) = delete;
    basic_filebuf& operator=(basic_filebuf&& rhs);
    void swap(basic_filebuf& rhs);
 
    // 成员：
    bool is_open() const;
    basic_filebuf<charT,traits>* open(const char* s, ios_base::openmode mode);
    basic_filebuf<charT,traits>* open(const string& s, ios_base::openmode mode);
    basic_filebuf<charT,traits>* close();
 
 protected:
    // 覆盖的虚函数：
    virtual streamsize showmanyc();
    virtual int_type underflow();
    virtual int_type uflow();
    virtual int_type pbackfail(int_type c = traits::eof());
    virtual int_type overflow (int_type c = traits::eof());
    virtual basic_streambuf<charT,traits>* setbuf(char_type* s, streamsize n);
    virtual pos_type seekoff(off_type off, ios_base::seekdir way,
                             ios_base::openmode which = ios_base::in|ios_base::out);
    virtual pos_type seekpos(pos_type sp,
                             ios_base::openmode which = ios_base::in|ios_base::out);
    virtual int sync();
    virtual void imbue(const locale& loc);
};

类 std::basic_ifstream

template <class charT, class traits = char_traits<charT> >
class basic_ifstream : public basic_istream<charT,traits> {
 public:
    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;
 
    // 构造函数：
    basic_ifstream();
    explicit basic_ifstream(const char* s, ios_base::openmode mode = ios_base::in);
    explicit basic_ifstream(const string& s, ios_base::openmode mode = ios_base::in);
    basic_ifstream(const basic_ifstream& rhs) = delete;
    basic_ifstream(basic_ifstream&& rhs);
 
    // 赋值/交换：
    basic_ifstream& operator=(const basic_ifstream& rhs) = delete;
    basic_ifstream& operator=(basic_ifstream&& rhs);
    void swap(basic_ifstream& rhs);
 
    // 成员：
    basic_filebuf<charT,traits>* rdbuf() const;
    bool is_open() const;
    void open(const char* s, ios_base::openmode mode = ios_base::in);
    void open(const string& s, ios_base::openmode mode = ios_base::in);
    void close();
 
 private:
    basic_filebuf<charT,traits> sb; // 仅用于阐释
};

类 std::basic_ofstream

template <class charT, class traits = char_traits<charT> >
class basic_ofstream : public basic_ostream<charT,traits> {
 public:
    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;
 
    // 构造函数：
    basic_ofstream();
    explicit basic_ofstream(const char* s, ios_base::openmode mode = ios_base::out);
    explicit basic_ofstream(const string& s, ios_base::openmode mode = ios_base::out);
    basic_ofstream(const basic_ofstream& rhs) = delete;
    basic_ofstream(basic_ofstream&& rhs);
 
    // 赋值/交换：
    basic_ofstream& operator=(const basic_ofstream& rhs) = delete;
    basic_ofstream& operator=(basic_ofstream&& rhs);
    void swap(basic_ofstream& rhs);
 
    // 成员：
    basic_filebuf<charT,traits>* rdbuf() const;
    bool is_open() const;
    void open(const char* s, ios_base::openmode mode = ios_base::out);
    void open(const string& s, ios_base::openmode mode = ios_base::out);
    void close();
 
 private:
    basic_filebuf<charT,traits> sb; // 仅用于阐释
};

类 std::basic_fstream

template <class charT, class traits=char_traits<charT> >
class basic_fstream : public basic_iostream<charT,traits> {
 public:
    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;
 
    // 构造函数/析构函数
    basic_fstream();
    explicit basic_fstream(const char* s,
                           ios_base::openmode mode = ios_base::in|ios_base::out);
    explicit basic_fstream(const string& s,
                           ios_base::openmode mode = ios_base::in|ios_base::out);
    basic_fstream(const basic_fstream& rhs) = delete;
    basic_fstream(basic_fstream&& rhs);
 
    // 赋值/交换：
    basic_fstream& operator=(const basic_fstream& rhs) = delete;
    basic_fstream& operator=(basic_fstream&& rhs);
    void swap(basic_fstream& rhs);
 
    // 成员：
    basic_filebuf<charT,traits>* rdbuf() const;
    bool is_open() const;
    void open(const char* s,
              ios_base::openmode mode = ios_base::in|ios_base::out);
    void open(const string& s,
              ios_base::openmode mode = ios_base::in|ios_base::out);
    void close();
 
 private:
    basic_filebuf<charT,traits> sb; // 仅用于阐释
};