关于c++:c中ifstream及ofstream超详细说明

前文说过，ifstream 是继承于 istream，ofstream 是继承于 ostream，fstream 是继承于 iostream 类，而他们应用的缓冲区类是 filebuf。

对于这些类之间的关系，有趣味能够去查看我之前的文章:
c++ 规范输入输出流关系梳理

1. filebuf 类介绍

filebuf 类又比 stringbuf 类要简单一点，毕竟是对文件进行读写，首先在它的成员变量中找到了这样一条申明：

__file_type         _M_file;

_M_file 就是它外面的文件操作对象，那么探索一下 __file_type 到底是什么类型呢，通过跟代码发现它其实是一个类模板 __basic_file 的 char 实例，而 __basic_file 是围绕一个 FILE类型的指针来进行操作的，而 FILE这个类型大家其实就很相熟啦，它是 c 语言规范库外面操作文件的规范类型，个别是叫做文件指针，所以从这里就能够看出 filebuf 最终其实还是基于 c 语言的 fopen 等这一套文件操作函数去进行解决的。当然啦，在 linux 外面 fopen 其实又是基于它的零碎调用 open 函数来进行的，这个咱们晓得就好，就不再做开展啦。

当看到 fopen 的调用时，其实心田是挺惊喜的，因为 fstream 这一套货色以前也常常应用，然而呢，从来不晓得它的底层到底是怎么实现的，这次总算是晓得了一点。

1.1 filebuf 类构造函数和析构函数

首先看一下 filebuf 的构造函数原型，如下：

// 这里申明了一个无参构造函数
basic_filebuf();
#if __cplusplus >= 201103L
      basic_filebuf(const basic_filebuf&) = delete;
// 这里申明了一个入参为右值援用的挪动构造函数，所谓右值援用，它容许内容从一个 filebuf 对象挪动到另外一个 filebuf 对象，挪动实现当前，源 filebuf 对象将被销毁，不能再被应用，它没有产生任何拷贝的动作
      basic_filebuf(basic_filebuf&&);
#endif
#if __cplusplus >= 201103L
      basic_filebuf& operator=(const basic_filebuf&) = delete;
// 同上，这里申明了一个挪动赋值函数
      basic_filebuf& operator=(basic_filebuf&&);
#endif
// 析构函数敞开文件
virtual
      ~basic_filebuf()
      {this->close(); }

小贴士：=delete 是 c ++11 的用法，在 c ++11 以前要避免类对象被拷贝和赋值，就要把拷贝构造函数和赋值函数申明为 private 的，到了 c ++11 就间接应用 =delete 来进行申明，它意味着这个函数不能被调用，否则编译就会报错。

从下面咱们能够看到 filebuf 类是不容许拷贝和赋值的，否则可能会产生多个对象操作同一个 IO 缓冲，就会导致诸多的问题，它只容许进行挪动，这样能保障任何时候同一个 IO 缓冲只有一个对象能够操作。

应用例子如下:

#include <fstream>
using namespace std;

int main()
{
    filebuf buf;
    filebuf buf2(move(buf));// 挪动构造函数，std::move 用于生成一个绑定在 buf 上的 filebuf&&
    filebuf buf3 = move(buf);// 挪动赋值函数
    return 0;
}

1.2 open 函数

函数原型如下：

//is_open 用于判断文件是否是关上状态，返回 true 则示意文件是关上状态，否则就是敞开状态      
bool
      is_open() const throw()
      {return _M_file.is_open(); }
//__s 示意文件名，__mode 示意文件打开方式
      __filebuf_type*
      open(const char* __s, ios_base::openmode __mode);
#if __cplusplus >= 201103L
// 同上，只是文件名应用了 string 示意而已
      __filebuf_type*
      open(const std::string& __s, ios_base::openmode __mode)
      {return open(__s.c_str(), __mode); }
#endif
// 敞开文件
      __filebuf_type*
      close();

应用案例如下：

#include <fstream>
#include <iostream>
using namespace std;

int main()
{
    filebuf buf;
    if (buf.open("aaa.txt", ios_base::in) == nullptr )
    {
        cout << "file open failed" << endl;
        return -1;
    }
    if (buf.is_open())
    {cout << "file is opened" << endl;}
    else
        cout << "file is closed" << endl;
    
    buf.close();// 能够调用也能够不调用，析构函数会主动敞开

    return 0;
}

还有其余函数这里就不多做介绍了，实践上来讲，咱们并不会间接应用 filebuf，因为它只是一个工具人，是幕后奉献者，是藏于暗中滴，大多数时候，咱们都是间接应用 ifstream 和 ofstream。

2. ifstream 类

2.1 构造函数和析构函数

ifstream 的构造函数除了默认无参构造函数以外，还基于 filebuf 的 open 函数申明了另外两个构造函数，fstream 头文件中原型如下：

// 默认的无参构造函数
basic_ifstream() : __istream_type(), _M_filebuf()
      {this->init(&_M_filebuf); }   
// 基于 filebuf 的 open 函数，申明了两个有参构造函数，默认是从文件读取数据
explicit
      basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in)
      : __istream_type(), _M_filebuf()
      {this->init(&_M_filebuf);
    this->open(__s, __mode);
      }

#if __cplusplus >= 201103L
      explicit
      basic_ifstream(const std::string& __s,
             ios_base::openmode __mode = ios_base::in)
      : __istream_type(), _M_filebuf()
      {this->init(&_M_filebuf);
    this->open(__s, __mode);
      }
    // 同样的，拷贝构造函数不容许应用
      basic_ifstream(const basic_ifstream&) = delete;

      basic_ifstream(basic_ifstream&& __rhs)
      : __istream_type(std::move(__rhs)),
      _M_filebuf(std::move(__rhs._M_filebuf))
      {__istream_type::set_rdbuf(&_M_filebuf); }
#endif
      ~basic_ifstream()
      { }
#if __cplusplus >= 201103L
      basic_ifstream&
      operator=(const basic_ifstream&) = delete;

      basic_ifstream&
      operator=(basic_ifstream&& __rhs)
      {__istream_type::operator=(std::move(__rhs));
    _M_filebuf = std::move(__rhs._M_filebuf);
    return *this;
      }

ifstream 的拷贝构造函数和赋值函数也是间接被禁用的，那么再调用有参的构造函数后，默认的文件就被关上了，无需再次调用 open 函数，能够看到它的析构函数是什么都没有做的，所以 ifstream 须要显式的调用 close 函数，如果不显式调用的话，filebuf 对象也会主动调用析构函数敞开文件，但如果 filebuf 调用 close 失败，就没方法晓得以后流的状态了。

2.2 swap 和 rdbuf 函数

函数原型如下：

// 替换两个 ifstream
void swap(basic_ifstream& __rhs);
// 返回一个指向以后 filebuf 缓冲区的指针
__filebuf_type*
      rdbuf() const;

一个应用案例如下：

#include <fstream>
#include <iostream>
#include <string.h>
using namespace std;

int main()
{char szIn[32] = {0};
    char szIn2[32] = {0};
    ifstream in("aaa.txt", ios_base::in);//aaa.txt 内容:0123456789
    ifstream in2("file.txt");// 应用默认打开方式, file.txt 内容 abcdefg 带换行符
    cout << "file aaa.txt size is" << in.rdbuf()->in_avail() << endl;
    in.read(szIn, 3);
    in2.read(szIn2, 3);
    cout << "in's content is "<< szIn << endl <<"in2's conteng is" << szIn2 <<endl;
    in.swap(in2);
    memset(szIn, 0x00, sizeof(szIn));
    memset(szIn2, 0x00, sizeof(szIn2));
    in.read(szIn, sizeof(szIn));
    in2.read(szIn2, sizeof(szIn2));
    cout << "in's content is "<< szIn << endl <<"in2's conteng is" << szIn2 <<endl;
    
    in.close();
    in2.close();

    return 0;
}

in_avail 是 streambuf 类外面的一个函数，用于返回以后缓冲区长度。

编译后执行后果如下：

[root@mylinux ~]# ./a.out 
file aaa.txt size is 10
in's content is 012
in2's conteng is abc
in's content is defg

in2's conteng is 3456789
[root@mylinux ~]#

通过后果能够看到 swap 函数并不会重置以后读的地位，根本是依照原样替换过去的。

2.3 open 和 close 函数

函数原型如下：

      bool
      is_open();
      bool
      is_open() const;
      void
      open(const char* __s, ios_base::openmode __mode = ios_base::in);
      void
      open(const std::string& __s, ios_base::openmode __mode = ios_base::in);
      void
      close()
      {if (!_M_filebuf.close())
      this->setstate(ios_base::failbit);
      }

open 函数和 is_open 函数用法与 filebuf 类基本一致，这里不再多说，次要是 close，咱们能够看到它调用失败当前，会将以后流状态置为失败，所以规范的做法，还是显式的调用一下 close 函数比拟好。

2.4 ofstream 类和 fstream 类

ofstream 用于往文件写入数据，除了结构和调用 open 函数的时候，默认的关上模式是 ios_base::out，其余所有函数应用都与 ifstream 截然不同，且用法也是一样的，包含 fstream 的函数用法，也是一样的，只是 fstream 默认关上模式是 ios_base::in | ios_base::out，其余函数的用法这里不再多说。

总之，咱们要记住，如果要从文件读取数据，那么应用 ifstream，如果要将数据写到文件，那么应用 ofstream，如果既要读又要写，那么应用 fstream。

3. stream 流关上模式

前文说到文件打开方式 ios_base::in 和 ios_base::out，实际上流打开方式不只这两种，上面就一一阐明一下：

在应用的时候，以 ’|’ 分隔，例如:ios_base::in|ios_base::out。

上面列几种不同场景下应用时的组合，如下：

以上场景都是针对文本文件进行读写的，如果想以同样的形式操作二进制文件，则在每个场景前面追加一个 ios_base::binary 即可。

这里在应用 ifstream 的时候要留神，不论是构造函数关上还是手动调用 open 函数关上文件，它在咱们指定的文件模式上会另外追加一个 ios_base::in，如下：

void
      open(const char* __s, ios_base::openmode __mode = ios_base::in)
      {if (!_M_filebuf.open(__s, __mode | ios_base::in))
      this->setstate(ios_base::failbit);
    else
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 409. Closing an fstream should clear error state
      this->clear();}

同理，ofstream 则会默认追加一个ios_base::out，但 fstream 则没有默认追加，不指定就默认ios_base::in|ios_base::out，如果指定了模式，则以指定的为准。

不晓得大家有没有发现一点，这里咱们始终没有说到 ios_base::ate 的应用场景，是认为我始终想不进去有用这个的必要性，惟一的场景是想关上文件的时候指针指向开端，而后续又可能从其余地位进行读写，就应用它，但在应用 ofstream 的时候如果指定了 ios_base::ate, 它又会因为默认追加的ios_base::out 而清空文件，这时惟一的办法是应用 fstream 类，并指定模式为ios_base::ate|ios_base::in|ios_base::out，这样才既没有清空文件，也满足了咱们的应用场景。