C++文件操作总结

 

C++文件操作总结

C++标准io结构图：

从结构图中可以看出:ios_base是整个c++IO继承体系的顶层结构，它主要定义了流

类型的格式化信息、状态信息及其它的一些信息。在这些信息中，iostate表示的是

文件io的状态，包括ios::eof等, 它表示的主文件的结尾标识，其中后面的ios中的

eof()方法表示返回的就是是否已经到达文件的结尾。它还定义了打开流的几种模式

，这对于我们而言，是非常重要的:

flag value

opening mode

app

(append) Set the stream's position indicator to the end of the stream before

each output operation.

ate

(at end) Set the stream's position indicator to the end of the stream on

 opening.   初始位置文件尾

binary

(binary) Consider stream as binary rather than text.   二进制方式

in

(input) Allow input operations on the stream.

out

(output) Allow output operations on the stream.

trunc

(truncate) Any current content is discarded, assuming a length of zero on

 opening. 如果文件已存在则先删除

对于ios而言，其官方解释为： The class is designed to be a base class for all of the

 hierarchy of stream classes.  在这个类中定义用于检测状态的函数: good()、eof()、

fail()和bad()等，它们均返回一个布尔类型的标识，用来表示相应的状态是否被设置。

 另外它还重写了!运算符，当其返回结果为true时表示true if either failbit or badbit is

set.

Iosteam中放置的都是常用的流操作类，而fstream头文件中放置的则是对文件进行操

作的基本类，而后面的sstream则是用于对字符串进行io操作的类。

C++ 通过以下几个类支持文件的输入输出：

Ø  ofstream: 写操作（输出）的文件类 (由ostream引申而来)

Ø  ifstream: 读操作（输入）的文件类(由istream引申而来)

Ø  fstream: 可同时读写操作的文件类 (由iostream引申而来)

1. fstream类的构造方法：

Ø  fstream ( );

Ø  explicit  fstream ( const char * filename, ios_base::openmode mode =

 ios_base::in | ios_base::out );

注:  explicit主要用于 "修饰 "构造函数， 使得它不用于程序中需要通过此构造函数进

行 "隐式 "转换的情况!  即如果有一个函数如果它的参数是double, 不加explicit时，

我们传入一个int类型的数据时是没有问题的，但当我们加入explicit则表示只能传

入一个double类型的参数。

2. 打开文件.

对流操作些类的一个对象所做的第一个操作通常就是将它和一个真正的文件联系起

来，也就是说打开一个文件。被打开的文件在程序中由一个流对象(stream object)来

表示 (这些类的一个实例) ，而对这个流对象所做的任何输入输出操作实际就是对该

文件所做的操作。

要通过一个流对象打开一个文件，我们使用它的成员函数open()：

void  open ( const char * filename,  ios_base::openmode mode =

 ios_base::in | ios_base::out );

这里filename 是一个字符串，代表要打开的文件名，mode 是以下标志符的一个组

合：这些标识符可以被组合使用，中间以”或”操作符(|)间隔。例如，如果我们想要

以二进制方式打开文件"example.bin" 来写入一些数据，我们可以通过以下方式调用

成员函数open（）来实现：

ofstream  file;
file.open ("example.bin",  ios::out | ios::app | ios::binary);

在这里， ofstream, ifstream 和 fstream所有这些类的成员函数open 都包含了一个

默认打开文件的方式，这三个类的默认方式各不相同：

类

参数的默认方式

ofstream

ios::out | ios::trunc

ifstream

ios::in

fstream

ios::in | ios::out

只有当函数被调用时没有声明方式参数的情况下，默认值才会被采用。如果函数被调

用时声明了任何参数，默认值将被完全改写，而不会与调用参数组合。由于对类

ofstream, ifstream 和 fstream 的对象所进行的第一个操作通常都是打开文件，这些类

都有一个构造函数可以直接调用open 函数，并拥有同样的参数。这样，我们就可以

通过以下方式进行与上面同样的定义对象和打开文件的操作：

ofstream   file ("example.bin", ios::out | ios::app | ios::binary);

两种打开文件的方式都是正确的。

你可以通过调用成员函数is_open()来检查一个文件是否已经被顺利的打开了：

 bool is_open();  它返回一个布尔(bool)值，为真（true）代表文件已经被顺利打开，

假( false )则相反。

3.关闭文件(Closing a file)

当文件读写操作完成之后，我们必须将文件关闭以使文件重新变为可访问的。关闭

文件需要调用成员函数close()，它负责将缓存中的数据排放出来并关闭文件。它的

格式很简单：

void    close ();

这个函数一旦被调用，原先的流对象(stream object)就可以被用来打开其它的文件

了，这个文件也就可以重新被其它的进程(process)所有访问了。为防止流对象被

销毁时还联系着打开的文件，析构函数(destructor)将会自动调用关闭函数close。

4. 文本文件读写

类ofstream, ifstream 和fstream 是分别从ostream, istream 和iostream 中引申而来的

。这就是为什么 fstream 的对象可以使用其父类的成员来访问数据。

一般来说，我们将使用这些类与同控制台(console)交互同样的成员函数(cin 和 cout)

来进行输入输出。如下面的例题所示，我们使用重载的插入操作符<<：

// writing on a text file

        #include <fiostream.h>

        using  namespace  std;

        int main () {

               ofstream examplefile ("example.txt");

               if (examplefile.is_open()) {

                        examplefile << "This is a line."n";

                        examplefile << "This is another 

           line."n";    examplefile.close();

                }

                return 0;

        }从文件中读入数据也可以用与 cin的使用同样的方法：

// reading a text file

        #include <iostream.h>

        #include <fstream.h>

        #include <stdlib.h>

using  namespace  std;

        int main () {

                 char   buffer[256];

                 ifstream   examplefile ("example.txt");

                if (! examplefile.is_open()){

cout << "Error opening file"; exit (1);

}

               while (! examplefile.eof() ) {

                       examplefile.getline (buffer,100);

                       cout << buffer << endl;

               }

               return 0;

}
上面的例子读入一个文本文件的内容，然后将它打印到屏幕上。注意我们使用了一个

新的成员函数叫做eof ，它是ifstream 从类

ios 中继承过来的，当到达文件末尾时返回true 。

5.状态标志符的验证(Verification of state flags)

除了eof()以外，还有一些验证流的状态的成员函数（所有都返回bool型返回值）：

²  bad()     如果在读写过程中出错，返回 true 。例如：当我们要对一个不是打开为写

状态的文件进行写入时，或者我们要写入的

设备没有剩余空间的时候。

²  fail()      除了与bad() 同样的情况下会返回 true 以外，加上格式错误时也返回true ，

例如当想要读入一个整数，而获得了一个

l  字母的时候。

²  eof()     如果读文件到达文件末尾，返回true。

²  good()    这是最通用的：如果调用以上任何一个函数返回true 的话，此函数返回

false 。

要想重置以上成员函数所检查的状态标志，你可以使用成员函数clear()，没有参数。

  一般在我们使用一个不知道情形的流时，我们可以先使用此方法来将所有流的状

态还原，然后再来进行相应的读写操作。

6. 获得和设置流指针(get and put stream pointers)

所有输入/输出流对象(i/o streams objects)都有至少一个流指针：

·         ifstream， 类似istream, 有一个被称为get pointer的指针，指向下一个将被读

取的元素。

·         ofstream, 类似 ostream, 有一个指针 put pointer ，指向写入下一个元素的位置。

·         fstream, 类似 iostream, 同时继承了get 和 put

我们可以通过使用以下成员函数来读出或配置这些指向流中读写位置的流指针：

(1) tellg() 和 tellp()

这两个成员函数不用传入参数，返回pos_type 类型的值(根据ANSI-C++ 标准) ，就

是一个整数，代表当前get 流指针的位置

(用tellg) 或 put 流指针的位置(用tellp).

(2) seekg() 和seekp()

这对函数分别用来改变流指针get 和put的位置。两个函数都被重载为两种不同的原

型：seekg ( pos_type position );
seekp ( pos_type position );    使用这个原型，流指针被改变为指向从文件开始计算

的一个绝对位置。要求传入的参数类型与函数 tellg 和tellp 的返回值类型相同。

 seekg ( off_type offset,   seekdir direction );    使用这个原型可以指定由参

数direction决定的一个具体的指针开始计算的一个位移(offset)。它可以是：

ios::beg

从流开始位置计算的位移

ios::cur

从流指针当前位置开始计算的位移

ios::end

从流末尾处开始计算的位移

流指针 get 和 put 的值对文本文件(text file)和二进制文件(binary file)的计算方法都

是不同的，因为文本模式的文件中某些特殊字符可能被修改。由于这个原因，建

议对以文本文件模式打开的文件总是使用seekg 和 seekp的第一种原型，而且不

要对tellg 或 tellp 的返回值进行修改。对二进制文件，你可以任意使用这些函数

，应该不会有任何意外的行为产生。

以下例子使用这些函数来获得一个二进制文件的大小：

// obtaining file size
#include <iostream.h>

           #include <fstream.h>

           using  namespace  std;

           const  char  * filename = "example.txt";

           int main () {

                         long  l,m;

                         ifstream file (filename,   ios::in|ios::binary);

                         l = file.tellg();

                        file.seekg (0, ios::end);    //移动到尾部

                         m = file.tellg();

                         file.close();

                         cout << "size of " << filename;

                         cout << " is " << (m-l) << " bytes."n";

                         return 0;

        }

7.  二进制文件(Binary files)

在二进制文件中，使用<< 和>>，以及函数（如getline）来操作符输入和输出数据，

没有什么实际意义，虽然它们是符合语法的。文件流包括两个为顺序读写数据特殊

设计的成员函数：write 和 read。第一个函数 (write) 是ostream 的一个成员函数，

都是被ofstream所继承。而read 是istream 的一个成员函数，被ifstream 所继承。

类 fstream 的对象同时拥有这两个函数。它们的原型是：  write ( char * buffer,

 streamsize size );  和    read ( char * buffer, streamsize size );   这里 buffer 是

一块内存的地址，用来存储或读出数据。参数size 是一个整数值，表示要从缓存

（buffer）中读出或写入的字符数。

// reading binary file

        #include <iostream>

        #include <fstream.h>        using namespace std;

 const char * filename = "example.txt";

        int main () {

                 char * buffer; 

                 long size;

                 ifstream  file (filename, ios::in|ios::binary|ios::ate);   //打开时就定义到尾部

                size = file.tellg();   //得到文件大小

                file.seekg (0, ios::beg);   //文件重新定位到头部

                buffer = new char [size];

                file.read (buffer, size);

                file.close();

         ofstream  wf;

wf.open("新文件”,ios::out||ios::binary);

                 wf.write(buf,size);

         wf.close();

                 cout << "the complete file is in a buffer";

                delete[] buffer;    //释放申请的内存

                return 0;

        }超大文件读写原理小示例:

int main()

{

        fstream rf,wf;

        rf.open("temp.txt",ios::in|ios::binary);

        wf.open("temp03.txt",ios::out|ios::binary);

        char buf[10];              //假设一次只读10个字节的数据

        while(!rf.eof())            //依次读写多次即可完成相关操作

        {

                rf.read(buf,10);

                wf.write(buf,10);

        }

        wf.close();

        rf.close();

        cout << "write end!" << endl;

        return 0;

}

扩展：  Java等上传工具上传超大文件使用的缓存技术就可以理解为先读取出来写成很多小的缓存文件，因为读的时候字节数组的长度受到限制， 等上传完了再依次将所有的缓存文件依次写入一个文件中即可，只要保证读出的数据放到一个正确的数组中即可。

8.  缓存和同步(Buffers and Synchronization)

当我们对文件流进行操作的时候，它们与一个streambuf 类型的缓存(buffer)联系在一起。这个缓存（buffer）实际是一块内存空间，作为流(stream)和物理文件的媒介。例如，对于一个输出流， 每次成员函数put (写一个单个字符)被调用，这个字符不是直接被写入该输出流所对应的物理文件中的，而是首先被插入到该流的缓存（buffer）中。 当缓存被排放出来(flush)时，它里面的所有数据或者被写入物理媒质中（如果是一个输出流的话），或者简单的被抹掉(如果是一个输入流的话)。这个过程称为同步(synchronization)，它会在以下任一情况下发生：

Ø  当文件被关闭时: 在文件被关闭之前，所有还没有被完全写出或读取的缓存都将被同步。

Ø  当缓存buffer 满时:缓存Buffers 有一定的空间限制。当缓存满时，它会被自动同步。

Ø  控制符明确指明:当遇到流中某些特定的控制符时，同步会发生。这些控制符包括：flush 和endl。

Ø  明确调用函数sync(): 调用成员函数sync() (无参数)可以引发立即同步。这个函数返回一个int 值，等于-1 表示流没有联系的缓存或操作失败。

在C++中，有一个stream这个类，所有的I/O都以这个“流”类为基础的，包括我们要认识的文件I/O，stream这个类有两个重要的运算符：

（1）、插入器(<<)
向流输出数据。比如说系统有一个默认的标准输出流(cout)，一般情况下就是指的显示器，所以，cout<<"Write Stdout"<<'n';就表示把字符串"Write Stdout"和换行字符('n')输出到标准输出流。

（2）、析取器(>>)
从流中输入数据。比如说系统有一个默认的标准输入流(cin)，一般情况下就是指的键盘，所以，cin>>x;就表示从标准输入流中读取一个指定类型(即变量x的类型)的数据。

附： C++和C的文件打开模式

C++模式

C模式

含义

ios_base::in

“r”

打开一读取

ios_base::out

“w”

等价于ios_base::out|ios_base::trunk(有时可以省略)

out|trunc

“w”

打开一些如文件，如果存在，则截取文件

out|app

“a”

打开以写入，只追加

in|out

“r+”

打开以写入，在文件读取的位置写入

in|out|trunc

“w+”

打开以读写，如果存在，则首先截取文件

out|binary

cmodeb

以C++mode和二进制模式打开，例如ios_base::in|ios_base::binary成为“rb”

out|ate

“cmode”

以指定的模式打开，并已到文件尾。C则需要使用独立的函数调用。例如，

ios_base::in|ios_base::ate则被转换为“r”和C函数调用fseek(file,0,SEEK_END);

对于app模式，只能追加，但是不能修改原来已经存在的数据，要是其能修改，则需要与out模式组合，即app|out。对于已经

处理到末尾的文件，eof位将被被设置为1，因此，如果想对文件再作修改，则需要调用函数fout.clear()终止流状态，否则禁止对文件作进一步读写操作。