一、 C++流的概念
在C++语言中，数据的输入和输出（简写为I/O）包括对标准输入设备键盘和标准输
出设备显示器、对在外存磁盘上的文件和对内存中指定的字符串存储空间（当然可
用该空间存储任何信息）进行输入输出这三个方面。对标准输入设备和标准输出设
备的输入输出简称为标准I/O，对在外存磁盘上文件的输入输出简称为文件I/O，对
内存中指定的字符串存储空间的输入输出简称为串I/O。
C++语言系统为实现数据的输入和输出定义了一个庞大的类库，它包括的类主要有ios,istream,ostream,iostream,ifstream,ofstream,fstream,istrstream,ostrs
tream,strstream等，其中ios为根基类，其余都是它的直接或间接派生类。
ios为根基类，它直接派生四个类：输入流类istream、输出流类ostream、文件流
基类fstreambase和字符串流基类strstreambase，输入文件流类同时继承了输入流
类和文件流基类（当然对于根基类是间接继承），输出文件流类ofstream同时继承了输出流类和文件流基类，输入字符串流类istrstream同时继承了输入流类和字符串流基类，输出字符串流类ostrstream同时继承了输出流类和字符串流基类，输入输出流类iostream同时继承了输入流类和输出流类，输入输出文件流类fstream同时继承了输入输出流类和文件流基类，输入输出字符串流类strstream同时继承了输入输出流类和字符串流基类。
“流”就是“流动”，是物质从一处向另一处流动的过程。C++流是指信息从外部输入设备（如键盘和磁盘）向计算机内部（即内存）输入和从内存向外部输出设备（如显示器和磁盘）输出的过程，这种输入输出过程被形象地比喻为“流”。为了实现信息的内外流动，C++系统定义了I/O类库，其中的每一个类都称作相应的流或流类，用以完成某一方面的功能。根据一个流类定义的对象也时常被称为流。如根据文件流类fstream定义的一个对象fio，可称作为fio流或fio文件流，用它可以同磁盘上一个文件相联系，实现对该文件的输入和输出，fio就等同于与之相联系的文件。
C++系统中的I/O类库，其所有类被包含在iostream.h,fstream.h和strstrea.h这三个系统头文件中，各头文件包含的类如下：
iostream.h包含有：ios, iostream, istream, ostream, iostream_withassign,
istream_withassign, ostream_withassign等。
fstream.h包含有：fstream, ifstream, ofstream和fstreambase，以及iostream.h
中的所有类。
Strstrea.h包含有：strstream, istrstream, ostrstream和strstreambase，以及
iostream.h中的所有类。
在一个程序或一个编译单元（即一个程序文件）中当需要进行标准I/O操作时，则必须包含头文件iostream.h，当需要进行文件I/O操作时，则必须包含头文件fstream.h，同样，当需要进行串I/O操作时，则必须包含头文件strstrea.h。在一个程序或编译单元中包含一个头文件的命令格式为“#include<头文件名>”，当然若头文件是用户建立的，则头文件名的两侧不是使用尖括号，而是使用双引号。当系统编译一个C++文件对#include命令进行处理时，是把该命令中指定的文件中的全部内容嵌入到该命令的位置，然后再编译整个C++文件生成相应的目标代码文件。
C++不仅定义有现成的I/O类库供用户使用，而且还为用户进行标准I/O操作定义了四个类对象，它们分别是cin,cout,cerr和clog，其中cin为istream_withassign流类的对象，代表标准输入设备键盘，也称为cin流或标准输入流，后三个为ostream_withassign流类的对象，cout代表标准输出设备显示器，也称为cout流或标准输出流，cerr和clog含义相同，均代表错误信息输出设备显示器。因此当进行键盘输入时使用cin流，当进行显示器输出时使用cout流，当进行错误信息输出时使用cerr或clog。
在istream输入流类中定义有对右移操作符>>重载的一组公用成员函数，函数的具体声明格式为：
istream& operator>>(简单类型标识符&);
简单类型标识符可以为char, signed char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, float, double, long double, char*, signed char*, unsigned char*之中的任何一种，对于每一种类型都对应着一个右移操作符重载函数。由于右移操作符重载用于给变量输入数据的操作，所以又称为提取操作符，即从流中提取出数据赋给变量。
当系统执行cin>>x操作时，将根据实参x的类型调用相应的提取操作符重载函数，把x引用传送给对应的形参，接着从键盘的输入中读入一个值并赋给x（因形参是x的别名）后，返回cin流，以便继续使用提取操作符为下一个变量输入数据。
当从键盘上输入数据时，只有当输入完数据并按下回车键后，系统才把该行数据存入到键盘缓冲区，供cin流顺序读取给变量。还有，从键盘上输入的每个数据之间必须用空格或回车符分开，因为cin为一个变量读入数据时是以空格或回车符作为其结束标志的。
当cin>>x操作中的x为字符指针类型时，则要求从键盘的输入中读取一个字符串，并把它赋值给x所指向的存储空间中，若x没有事先指向一个允许写入信息的存储空间，则无法完成输入操作。另外从键盘上输入的字符串，其两边不能带有双引号定界符，若带有只作为双引号字符看待。对于输入的字符也是如此，不能带有单引号定界符。
在ostream输出流类中定义有对左移操作符<<重载的一组公用成员函数，函数的具体声明格式为：
ostream& operator<<(简单类型标识符);
简单类型标识符除了与在istream流类中声明右移操作符重载函数给出的所有简单类型标识符相同以外，还增加一个void* 类型，用于输出任何指针（但不能是字符指针，因为它将被作为字符串处理，即输出所指向存储空间中保存的一个字符串）的值。由于左移操作符重载用于向流中输出表达式的值，所以又称为插入操作符。如当输出流是cout时，则就把表达式的值插入到显示器上，即输出到显示器显示出来。
当系统执行cout<<x操作时，首先根据x值的类型调用相应的插入操作符重载函数，把x的值按值传送给对应的形参，接着执行函数体，把x的值（亦即形参的值）输出到显示器屏幕上，从当前屏幕光标位置起显示出来，然后返回cout流，以便继续使用插入操作符输出下一个表达式的值。当使用插入操作符向一个流输出一个值后，再输出下一个值时将被紧接着放在上一个值的后面，所以为了让流中前后两个值分开，可以在输出一个值之后接着输出一个空格，或一个换行符，或其他所需要的字符或字符串。
二、 输入输出格式控制
1．ios类中的枚举常量
在根基类ios中定义有三个用户需要使用的枚举类型，由于它们是在公用成员部分定义的，所以其中的每个枚举类型常量在加上ios::前缀后都可以为本类成员函数和所有外部函数访问。在三个枚举类型中有一个无名枚举类型，其中定义的每个枚举常量都是用于设置控制输入输出格式的标志使用的。该枚举类型定义如下：
enum {skipws, left, right, internal, dec, oct, hex, showbase,
showpoint, uppercase, showpos, scientific, fixed, unitbuf, stdio
};
各枚举常量的含义如下：
skipws
利用它设置对应标志后，从流中输入数据时跳过当前位置及后面的所有连续的空白字符，从第一个非空白字符起读数，否则不跳过空白字符。空格、制表符’\t’、回车符’\r’和换行符’\n’统称为空白符。缺省为设置。
left, right, internal
left在指定的域宽内按左对齐输出，right按右对齐输出，而internal使数值的符号按左对齐、数值本身按右对齐输出。域宽内剩余的字符位置用填充符填充。缺省为right设置。在任一时刻只有一种有效。
dec, oct, hex
设置dec对应标志后，使以后的数值按十进制输出，设置oct后按八进制输出，而设置hex后则按十六进制输出。缺省为dec设置。
showbase
设置对应标志后使数值输出的前面加上“基指示符”，八进制数的基指示符为数字0，十六进制数的基指示符为0x，十进制数没有基指示符。缺省为不设置，即在数值输出的前面不加基指示符。
showpoint
强制输出的浮点数中带有小数点和小数尾部的无效数字0。缺省为不设置。
uppercase
使输出的十六进制数和浮点数中使用的字母为大写。缺省为不设置。即输出的十六进制数和浮点数中使用的字母为小写。
showpos
使输出的正数前带有正号“+”。缺省为不设置。即输出的正数前不带任何符号。
scientific, fixed
进行scientific设置后使浮点数按科学表示法输出，进行fixed设置后使浮点数按定点表示法输出。只能任设其一。缺省时由系统根据输出的数值选用合适的表示输出。
unitbuf, stdio
这两个常量很少使用，所以不予介绍。
在ios中定义的第二个枚举类型为：
enum open_mode {in, out, ate, app, trunc, nocreate, noreplace, binany};
其中的每个枚举常量规定一种文件打开的方式，在定义文件流对象和打开文件时使用。
在ios中定义的第三个枚举类型为：
enum seek_dir {beg, cur, end};
其中的每个枚举常量用于对文件指针的定位操作上。
2. ios类中的成员函数
ios类提供成员函数对流的状态进行检测和进行输入输出格式控制等操作，每个成员函数的声明格式和简要说明如下：
int bad(); //操作出错时返回非0值。
int eof(); //读取到流中最后的文件结束符时返回非0值。
int fail(); //操作失败时返回非0值。
void clear(); //清除bad,eof和fail所对应的标志状态，使之恢复为正常状态
//值0，使good标志状态恢复为1。
char fill(); //返回当前使用的填充字符。
char fill(char c); //重新设置流中用于输出数据的填充字符为c的值，返回此
//前的填充字符。系统预设置填充字符为空格。
long flags(); //返回当前用于I/O控制的格式状态字。
long flags(long f); //重新设置格式状态字为f的值，返回此前的格式状态字。
int good(); //操作正常时返回非0值，当操作出错、失败和读到文件结束符时
//均为不正常，则返回0。
int precision(); //返回浮点数输出精度，即输出的有效数字的位数。
int precision(int n); //设置浮点数的输出精度为n，返回此前的输出精度。
//系统预设置的输出精度为6，即输出的浮点数最多
//具有6位为有效数字。
int rdstate(); //操作正常时返回0，否则返回非0值，它与good()正好相反。
long setf(long f); //根据参数f设置相应的格式化标志，返回此前的设置。
//该参数f所对应的实参为无名枚举类型中的枚举常量（
//又称格式化常量），可以同时使用一个或多个常量，每两个
//常量之间要用按位或操作符连接。如当需要左对齐输出，
//并使数值中的字母大写时，则调用该函数的实参为ios::
//left | ios::uppercase。
long unsetf(long f); //根据参数f清除相应的格式化标志，返回此前的设置。
//如要清除此前的左对齐输出设置，恢复缺省的右对齐输出
//设置，则调用该函数的实参为ios::left。
int width(); //返回当前的输出域宽。若返回数值0则表明没有为刚才输出的
//数值设置输出域宽，输出域宽是指输出的值在流中所占有的字节数。
int width(int w); //设置下一个数据值的输出域宽为w，返回为输出上一个数
//据值所规定的域宽，若无规定则返回0。注意：此设置不
//是一直有效，而只是对下一个输出数据有效。
因为所有I/O流类都是ios的派生类，所以它们的对象都可以调用ios类中的成员函数和使用ios类中的格式化常量进行输入输出格式控制。下面以标准输出流对象cout为例说明输出的格式化控制。
程序1：
#include<iostream.h>
void main()
{
int x=30, y=300, z=1024;
cout<<x<<' '<<y<<' '<<z<<endl; //按十进制输出
cout.setf(ios::oct); //设置为八进制输出
cout<<x<<' '<<y<<' '<<z<<endl; //按八进制输出
cout.unsetf(ios::oct);
//取消八进制输出设置，恢复按十进制输出
cout.setf(ios::hex); //设置为十六进制输出
cout<<x<<' '<<y<<' '<<z<<endl; //按十六进制输出
cout.setf(ios::showbase | ios::uppercase);
//设置基指示符输出和数值中的字母大写输出
cout<<x<<' '<<y<<' '<<z<<endl;
cout.unsetf(ios::showbase | ios::uppercase);
//取消基指示符输出和数值中的字母大写输出
cout<<x<<' '<<y<<' '<<z<<endl;
cout.unsetf(ios::hex);
//取消十六进制输出设置，恢复按十进制输出
cout<<x<<' '<<y<<' '<<z<<endl;
}
此程序的运行结果如下：
30 300 1024
36 454 2000
1e 12c 400
0X1E 0X12C 0X400
1e 12c 400
30 300 1024
程序2：
#include<iostream.h>
void main()
{
int x=468;
double y=-3.425648;
cout<<"x=";
cout.width(10); //设置输出下一个数据的域宽为10
cout<<x; //按缺省的右对齐输出，剩余位置填充空格字符
cout<<"y=";
cout.width(10); //设置输出下一个数据的域宽为10
cout<<y<<endl;
cout.setf(ios::left); //设置按左对齐输出
cout<<"x=";
cout.width(10);
cout<<x;
cout<<"y=";
cout.width(10);
cout<<y<<endl;
cout.fill('*'); //设置填充字符为'*'
cout.precision(3); //设置浮点数输出精度为3
cout.setf(ios::showpos); //设置正数的正号输出
cout<<"x=";
cout.width(10);
cout<<x;
cout<<"y=";
cout.width(10);
cout<<y<<endl;
}
此程序运行结果如下：
x= 468y= -3.42565
x=468 y=-3.42565
x=+468******y=-3.43*****
程序3：
#include<iostream.h>
void main()
{
float x=25, y=-4.762;
cout<<x<<' '<<y<<endl;
cout.setf(ios::showpoint); //强制显示小数点和无效0
cout<<x<<' '<<y<<endl;
cout.unsetf(ios::showpoint); //恢复缺省输出
cout.setf(ios::scientific); //设置按科学表示法输出
cout<<x<<' '<<y<<endl;
cout.setf(ios::fixed); //设置按定点表示法输出
cout<<x<<' '<<y<<endl;
}
程序运行结果如下：
25 -4.762
25.0000 -4.76200
2.500000e+001 -4.762000e+000
25 -4.762
3. 格式控制操作符
数据输入输出的格式控制还有更简便的形式，就是使用系统头文件iomanip.h中提供的操纵符。使用这些操纵符不需要调用成员函数，只要把它们作为插入操作符<<（个别作为提取操作符>>）的输出对象即可。这些操纵符及功能如下：
dec //转换为按十进制输出整数，它也是系统预置的进制。
oct //转换为按八进制输出整数。
hex //转换为按十六进制输出整数。
ws //从输入流中读取空白字符。
endl //输出换行符’\n’并刷新流。刷新流是指把流缓冲区的内容立即写入到对
//应的物理设备上。
ends //输出一个空字符’\0’。
flush //只刷新一个输出流。
setiosflags(long f) //设置f所对应的格式化标志，功能与setf(long f)
//成员函数相同，当然输出该操纵符后返回的是一个
//输出流。如采用标准输出流cout输出它时，则返回
//cout。对于输出每个操纵符后也都是如此，即返回
//输出它的流，以便向流中继续插入下一个数据。
resetiosflags(long f) //清除f所对应的格式化标志，功能与unsetf(long f)
//成员函数相同。当然输出后返回一个流。
setfill(int c) //设置填充字符为ASCII码为c的字符。
setprecision(int n) //设置浮点数的输出精度为n。
setw(int w) //设置下一个数据的输出域宽为w。
在上面的操纵符中，dec, oce, hex, endl, ends, flush和ws除了在iomanip.h中有定义外，在iostream.h中也有定义。所以当程序或编译单元中只需要使用这些不带参数的操纵符时，可以只包含iostream.h文件，而不需要包含iomanip.h文件。
下面以标准输出流对象cout为例，说明使用操作符进行的输出格式化控制。
程序4：
#include<iostream.h>
//因iomanip.h中包含有iostream.h，所以该命令可省略
#include<iomanip.h>
void main()
{
int x=30, y=300, z=1024;
cout<<x<<' '<<y<<' '<<z<<endl; //按十进制输出
cout<<oct<<x<<' '<<y<<' '<<z<<endl; //按八进制输出
cout<<hex<<x<<' '<<y<<' '<<z<<endl; //按十六进制输出
cout<<setiosflags(ios::showbase | ios::uppercase);
//设置基指示符和数值中的字母大写输出
cout<<x<<' '<<y<<' '<<z<<endl; //仍按十六进制输出
cout<<resetiosflags(ios::showbase | ios::uppercase);
//取消基指示符和数值中的字母大写输出
cout<<x<<' '<<y<<' '<<z<<endl; //仍按十六进制输出
cout<<dec<<x<<' '<<y<<' '<<z<<endl; //按十进制输出
}
此程序的功能和运行结果都与程序1完全相同。
程序5：
#include<iostream.h>
#include<iomanip.h>
void main()
{
int x=468;
double y=-3.425648;
cout<<"x="<<setw(10)<<x;
cout<<"y="<<setw(10)<<y<<endl;
cout<<setiosflags(ios::left); //设置按左对齐输出
cout<<"x="<<setw(10)<<x;
cout<<"y="<<setw(10)<<y<<endl;
cout<<setfill('*'); //设置填充字符为'*'
cout<<setprecision(3); //设置浮点数输出精度为3
cout<<setiosflags(ios::showpos); //设置正数的正号输出
cout<<"x="<<setw(10)<<x;
cout<<"y="<<setw(10)<<y<<endl;
cout<<resetiosflags(ios::left | ios::showpos);
cout<<setfill(' ');
}
此程序的功能和运行结果完全与程序2相同。
程序6：
#include<iomanip.h>
void main()
{
float x=25, y=-4.762;
cout<<x<<' '<<y<<endl;
cout<<setiosflags(ios::showpoint);
cout<<x<<' '<<y<<endl;
cout<<resetiosflags(ios::showpoint);
cout<<setiosflags(ios::scientific);
cout<<x<<' '<<y<<endl;
cout<<setiosflags(ios::fixed);
cout<<x<<' '<<y<<endl;
}
此程序的功能和运行结果也完全与程序3相同。
三、文件操作
1. 文件的概念
以前进行的输入输出操作都是在键盘和显示器上进行的，通过键盘向程序输入待处理的数据，通过显示器输出程序运行过程中需要告诉用户的信息。键盘是C++系统中的标准输入设备，用cin流表示，显示器是C++系统中的标准输出设备，用cout流表示。
数据的输入和输出除了可以在键盘和显示器上进行之外，还可以在磁盘上进行。磁盘是外部存储器，它能够永久保存信息，并能够被重新读写和携带使用。所以若用户需要把信息保存起来，以便下次使用，则必须把它存储到外存磁盘上。
在磁盘上保存的信息是按文件的形式组织的，每个文件都对应一个文件名，并且属于某个物理盘或逻辑盘的目录层次结构中一个确定的目录之下。一个文件名由文件主名和扩展名两部分组成，它们之间用圆点（即小数点）分开，扩展名可以省略，当省略时也要省略掉前面的圆点。文件主名是由用户命名的一个有效的C++标识符，为了同其他软件系统兼容，一般让文件主名为不超过8个有效字符的标识符，同时为了便于记忆和使用，最好使文件主名的含义与所存的文件内容相一致。文件扩展名也是由用户命名的、1至3个字符组成的、有效的C++标识符，通常用它来区分文件的类型。如在C++系统中，用扩展名h表示头文件，用扩展名cpp表示程序文件，用obj表示程序文件被编译后生成的目标文件，用exe表示连接整个程序中所有目标文件后生成的可执行文件。对于用户建立的用于保存数据的文件，通常用dat表示扩展名，若它是由字符构成的文本文件则也用txt作为扩展名，若它是由字节构成的、能够进行随机存取的内部格式文件则可用ran表示扩展名。
在C++程序中使用的保存数据的文件按存储格式分为两种类型，一种为字符格式文件，简称字符文件，另一种为内部格式文件，简称字节文件。字符文件又称ASCII码文件或文本文件，字节文件又称二进制文件。在字符文件中，每个字节单元的内容为字符的ASCII码，被读出后能够直接送到显示器或打印机上显示或打印出对应的字符，供人们直接阅读。在字节文件中，文件内容是数据的内部表示，是从内存中直接复制过来的。当然对于字符信息，数据的内部表示就是ASCII码表示，所以在字符文件和在字节文件中保存的字符信息没有差别，但对于数值信息，数据的内部表示和ASCII码表示截然不同，所以在字符文件和在字节文件中保存的数值信息也截然不同。如对于一个短整型数1069，它的内部表示占有两个字节，对应的十六进制编码为04 2D，其中04为高字节值，2D为低字节值；若用ASCII码表示则为四个字节，每个字节依次为1069中每个字符的ASCII码，对应的十六进制编码为31 30 36 39。当从内存向字符文件输出数值数据时需要自动转换成它的ASCII码表示，相反，当从字符文件向内存输入数值数据时也需要自动将它转换为内部表示，而对于字节文件的输入输出则不需要转换，仅是内外存信息的直接拷贝，显然比字符文件的输入输出要快得多。所以当建立的文件主要是为了进行数据处理时，则适宜建立成字节文件，若主要是为了输出到显示器或打印机供人们阅读，或者是为了供其他软件使用时，则适宜建立成字符文件。另外，当向字符文件输出一个换行符’\n’时，则将被看作为输出了回车’\r’和换行’\n’两个字符；相反，当从字符文件中读取回车和换行两个连续字符时，也被看作为一个换行符读取。
C++程序文件，利用其他各种语言编写的程序文件，用户建立的各种文本文件，各种软件系统中的帮助文件等，因都是ASCII码文件，所以都可以在C++中作为字符文件使用。
C++系统把各种外部设备也看作为相应的文件。如把标准输入设备键盘和标准输出设备显示器看作为标准输入输出文件，其文件名（又称设备名）为con，当向它输出信息时就是输出到显示器，当从它输入信息时就是从键盘输入。标准输入输出文件con对应两个系统预定义的流，即标准输入流cin和标准输出流cout，分别用于键盘输入和显示器输出。由于键盘和显示器都属于字符设备，所以它们都是字符格式文件。以后对字符文件所介绍的访问操作也同样适应于键盘和显示器，而以前介绍的对键盘(cin)和显示器(cout)的访问操作也同样适应于所有字符文件。
无论是字符文件还是字节文件，在访问它之前都要定义一个文件流类的对象，并用该对象打开它，以后对该对象的访问操作就是对被它打开文件的访问操作。对文件操作结束后，再用该对象关闭它。对文件的访问操作包括输入和输出两种操作，输入操作是指从外部文件向内存变量输入数据，实际上是系统先把文件内容读入到该文件的内存缓冲区中，然后再从内存缓冲区中取出数据并赋给相应的内存变量，用于输入操作的文件称为输入文件。对文件的输出操作是指把内存变量或表达式的值写入到外部文件中，实际上是先写入到该文件的内存缓冲区中，待缓冲区被写满后，再由系统一次写入到外部文件中，用于输出操作的文件称为输出文件。
一个文件中保存的内容是按字节从数值0开始顺序编址的，文件开始位置的字节地址为0，文件内容的最后一个字节的地址为n-1（假定文件长度为n，即文件中所包含的字节数），文件最后存放的文件结束符的地址为n，它也是该文件的长度值。当一个文件为空时，其开始位置和最后位置（即文件结束符位置）同为0地址位置。
对于每个打开的文件，都存在着一个文件指针，初始指向一个隐含的位置，该位置由具体打开方式决定。每次对文件写入或读出信息都是从当前文件指针所指的位置开始的，当写入或读出若干个字节后，文件指针就后移相应多个字节。当文件指针移动到最后，读出的是文件结束符时，则将使流对象调用eof()成员函数返回非0值（通常为1），当然读出的是文件内容时将返回0。文件结束符占有一个字节，其值为-1，在ios类中把EOF常量定义为-1。若利用字符变量依次读取字符文件中的每个字符，当读取到的字符等于文件结束符EOF时则表示文件访问结束。
要在程序中使用文件时，首先要在开始包含#include<fstream.h>命令。由它提供的输入文件流类ifstream、输出文件流类ofstream和输入输出文件流类fstream定义用户所需要的文件流对象，然后利用该对象调用相应类中的open成员函数，按照一定的打开方式打开一个文件。文件被打开后，就可以通过流对象访问它了，访问结束后再通过流对象关闭它。
每个文件流类都有一个open成员函数，并且具有完全相同的声明格式，具体声明格式为：
void open(const char* fname, int mode);
其中fname参数用于指向要打开文件的文件名字符串，该字符串内可以带有盘符和路径名，若省略盘符和路径名则隐含为当前盘和当前路径，mode参数用于指定打开文件的方式，对应的实参是ios类中定义的open_mode枚举类型中的枚举常量，或由这些枚举常量构成的按位或表达式。
open_mode枚举类型中的每个枚举常量的含义如下：
ios::in //使文件只用于数据输入，即从中读取数据。
ios::out //使文件只用于数据输出，即向它写入数据。
ios::ate //使文件指针移至文件尾，即最后位置。
ios::app //使文件指针移至文件尾，并只允许向文件尾输出（即追加）数据。
ios::trunc //若打开的文件存在，则清除其全部内容，使之变为空文件。
ios::nocreate //若打开的文件不存在则不建立它，返回打开失败信息。
ios::noreplace //若打开的文件存在则返回打开失败信息。
ios::binary //规定打开的为二进制文件，否则打开的为字符文件。
下面对文件的打开方式作几点说明：
(1) 文件的打开方式可以为上述的一个枚举常量，也可以为多个枚举常量构成的按位或表达式。如：
ios::in | ios::nocreate //规定打开的文件是输入文件，若文件不存在则返回
//打开失败信息。
ios::in | ios::out //规定打开的文件同时用于输入和输出。
ios::app | ios::nocreate //规定只向打开的文件尾追加数据，若文件不存在
//则返回打开失败信息。
ios::out | ios::noreplace //规定打开的文件是输出文件，若文件存在则返回
//打开失败信息。
ios::in | ios::out | ios::binary //规定打开的文件是二进制文件，并可同时
//用于输入和输出。
(2) 使用open成员函数打开一个文件时，若由字符指针参数所指定的文件不存在，则就建立该文件，当然建立的新文件是一个长度为0的空文件，但若打开方式参数中含有ios::nocreate选项，则不建立新文件，并且返回打开失败信息。
(3) 当打开方式中不含有ios::ate或ios::app选项时，则文件指针被自动移到文件的开始位置，即字节地址为0的位置。当打开方式中含有ios::out选项，但不含有ios::in,ios::ate或ios::app选项时，若打开的文件存在，则原有内容被清除，使之变为一个空文件。
(4) 当用输入文件流对象调用open成员函数打开一个文件时，打开方式参数可以省略，缺省按ios::in方式打开，若打开方式参数中不含有ios::in选项时，则会自动被加上。当用输出文件流对象调用open成员函数打开一个文件时，打开方式参数也可以省略，缺省按ios::out方式打开，若打开方式参数中不含有ios::out选项时，则也会自动被加上。
下面给出定义文件流对象和打开文件的一些例子：
(1) ofstream fout;
fout.open(“a:\\xxk.dat”); //字符串中的双反斜线表示一个反斜线
(2) ifstream fin;
fin.open(“a:\\wr.dat”, ios::in | ios::nocreate);
(3) ofstream ofs;
ofs.open(“a:\\xxk.dat”, ios::app);
(4) fstream fio;
fio.open(“a:\\abc.ran”, ios::in | ios::out | ios::binary);
例子(1)首先定义了一个输出文件流对象fout，使系统为其分配一个文件缓冲区，然后调用open成员函数打开a盘上的xxk.dat文件，由于调用的成员函数省略了打开方式参数，所以采用缺省的ios::out方式。执行这个调用时，若a:xxk.dat文件存在，则清除该文件内容，使之成为一个空文件，若该文件不存在，则就在a盘上建立名为xxk.dat的空文件。通过fout流打开a:xxk.dat文件后，以后对fout流的输出操作就是对a:xxk.dat文件的输出操作。
例子(2)首先定义了一个输入文件流对象fin，并使其在内存中得到一个文件缓冲区，然后打开a盘上的wr.dat文件，并规定以输入方式进行访问，若该文件不存在则不建立新文件，使打开该文件的操作失败，此时由fin带回0值，由(!fin)是否为真判断打开是否失败。
例子(3)首先定义了一个输出文件流对象ofs，同样在内存中得到一个文件缓冲区，然后打开a盘上已存在的xxk.dat文件，并规定以追加数据的方式访问，即不破坏原有文件中的内容，只允许向尾部写入新的数据。
例子(4)首先定义了一个输入输出文件流对象fio，同样在内存中得到一个文件缓冲区，然后按输入和输出方式打开a盘上的abc.ran二进制文件。此后既可以按字节向该文件写入信息，又可以从该文件读出信息。
在每一种文件流类中，既定义有无参构造函数，又定义有带参构造函数，并且所带参数与open成员函数所带参数完全相同。当定义一个带有实参表的文件流对象时，将自动调用相应的带参构造函数，打开第一个实参所指向的文件，并规定按第二个实参所给的打开方式进行操作。所以它同先定义不带参数的文件流对象，后通过流对象调用open成员函数打开文件的功能完全相同。对于上述给出的四个例子，依次与下面的文件流定义语句功能相同。
(1) ofstream fout(“a:\\xxk.dat”);
(2) ifstream fin(“a:\\wr.dat”, ios::in | ios::nocreate);
(3) ofstream ofs(“a:\\xxk.dat”, ios::app);
(4) fstream ofs(a:\abc.ran”, ios::in | ios::out | ios::binary);
每个文件流类中都提供有一个关闭文件的成员函数close()，当打开的文件操作结束后，就需要关闭它，使文件流与对应的物理文件断开联系，并能够保证最后输出到文件缓冲区中的内容，无论是否已满，都将立即写入到对应的物理文件中。文件流对应的文件被关闭后，还可以利用该文件流调用open成员函数打开其他的文件。
关闭任何一个流对象所对应的文件，就是用这个流对象调用close()成员函数即可。如要关闭fout流所对应的a:\xxk.dat文件，则关闭语句为：
fout.close();
2. 字符文件的访问操作
C++文件包括字符文件和字节文件两种类型，对它们的访问操作各不相同。这一小节专门讨论对字符文件的访问操作，下一小节再讨论对字节文件的访问操作。
当只需要对数据进行顺序输入输出操作时，则适合使用字符文件。对字符文件的访问操作包括向字符文件顺序输出数据和从字符文件顺序输入数据这两个方面。所谓顺序输出就是依次把数据写入到文件的末尾（当然文件结束符也随之后移，它始终占据整个文件空间的最后一个字节位置），顺序输入就是从文件开始位置起依次向后提取数据，直到碰到文件结束符为止。
(1) 向字符文件输出数据
向字符文件输出数据有两种方法，一种是调用从ostream流类中继承来的插入操作符重载函数，另一种是调用从ostream流类中继承来的put成员函数。它们的声明格式如下：
ostream& operator<<( 简单类型 );
ostream& put( char );
采用第一种方法时，插入操作符左边是文件流对象，右边是要输出到该文件流（即对应的文件）中数据项。当系统执行这种插入操作时，首先计算出插入操作符右边数据项（即表达式）的值，接着根据该值的类型调用相应的插入操作符重载函数，把这个值插入（即输出）到插入操作符左边的文件流中，然后返回这个流，以便在一条输出语句中继续输出其他数据。
若要向字符文件中插入一个用户定义类型的数据，除了可以将每个域的值依次插入外，还可以进行整体插入。对于后者，要预先定义有对该类型数据进行插入操作符重载的函数。
采用第二种方法时，文件流对象通过点操作符、文件流指针通过箭头操作符调用成员函数put。当执行这种调用操作时，首先向文件流中输出一个字符，即实参的值，然后返回这个文件流。
下面给出几个进行字符文件操作的例子。
例1. 向a盘上的wr1.dat文件输出0~20之间的整数，含0和20在内。
#include<iostream.h>
#include<stdlib.h>
#include<fstream.h>
void main(void)
{
ofstream f1("a:wr1.dat");
//定义输出文件流，并打开相应文件，若打开失败则f1带回0值
if (!f1) { //当f1打开失败时进行错误处理
cerr<<"a:wr1.dat file not open!"<<endl;
exit(1);
}
for(int i=0;i<21;i++)
f1<<i<<" "; //向f1文件流输出i值
f1.close(); //关闭f1所对应的文件
}
例2. 把从键盘上输入的若干行文本字符原原本本地存入到a盘上wr2.dat文件中，直到从键盘上按下Ctrl+z组合键为止。此组合键代表文件结束符EOF。
#include<iostream.h>
#include<stdlib.h>
#include<fstream.h>
void main(void)
{
char ch;
ofstream f2("a:wr2.dat");
if (!f2) { //当f1打开失败时进行错误处理
cerr<<"File of a:wr2.dat not open!"<<endl;
exit(1);
}
ch=cin.get(); //从cin流中提取一个字符到ch中
while(ch!=EOF) {
f2.put(ch); //把ch字符写入到f2流中，此语句也
//可用f2<<ch代替
ch=cin.get(); //从cin流中提取下一个字符到ch中
}
f2.close(); //关闭f2所对应的文件
}
例3. 假定一个结构数组a中的元素类型pupil包含有表示姓名的字符指针域name和表示成绩的整数域grade，试编写一个函数把该数组中的n个元素输出到字符文件“a:wr3.dat”中。
#include<stdlib.h>
#include<fstream.h>
void ArrayOut(pupil a[], int n)
{
ofstream f3("a:wr3.dat");
if (!f3) { //当f3打开失败时进行错误处理
cerr<<"File of a:wr3.dat not open!"<<endl;
exit(1);
}
for(int i=0; i<n; i++)
f3<<a[i].name<<endl<<a[i].grade<<endl;
f3.close();
}
若已经为输出pupil类型的数据定义了如下插入操作符重载函数：
ostream& operator<<(ostream& ostr, pupil& x)
{
ostr<<x.name<<endl<<x.grade<<endl;
return ostr;
}
则可将上述函数中for循环体语句修改为“f3<<a[i];”。
(2) 从字符文件输入数据
从打开的字符文件中输入数据到内存变量有三种方法。一种是调用提取操作符重载成员函数，每次从文件流中提取用空白符隔开（当然最后一个数据以文件结束符为结束标志）的一个数据，这同使用提取操作符从cin流中读取数据的过程和规定完全相同，在读取一个数据前文件指针自动跳过空白字符，向后移到非空白字符时读取一个数据。第二种是调用get()成员函数，每次从文件流中提取一个字符（不跳过任何字符，当然回车和换行两个字符被作为一个换行字符看待）并作为返回值返回，或者调用get(char&)成员函数，每次从文件流中提取一个字符到引用变量中，同样不跳过任何字符。第三种是调用getline(char* buffer, int len, char=’\n’)成员函数，每次从文件流中提取以换行符隔开（当然最后一行数据以文件结束符为结束标志）的一行字符到字符指针buffer所指向的存储空间中，若碰到换行符之前所提取字符的个数大于等于参数len的值，则本次只提取len-1个字符，被提取的一行字符是作为字符串写入到buffer所指向的存储空间中的，也就是说在一行字符的最后位置必须写入’\0’字符。文件流调用的上述各种成员函数都是在istream流类中定义的，它们都被每一种文件流类继承了下来，所以文件流类的对象可以直接调用它们。由于cin和cout流对象所属的流类也分别是istream流类和ostream流类的派生类，所以cin和cout也可以直接调用相应流类中的成员函数。
上述介绍的在istream流类中的每个成员函数的声明格式分别如下：
istream& operator>>( 简单类型& );
//从流中提取一个数据到引用对象中
int get(); //返回从流中提取到的一个字符
istream& get(char&); //从流中提取一个字符到字符引用中
istream& getline(char* buffer, int len, char=’\n’);
//从流中提取一行字符到由字符指针所指向的存储空间中
当使用流对象调用get()成员函数时，通过判断返回值是否等于文件结束符EOF可知文件中的数据是否被输入完毕。当使用流对象调用其他三个成员函数时，若提取成功则返回非0值，若提取失败（即已经读到文件结束符，未读到文件内容）则返回0值。
在通常情况下，若一个文件是使用插入操作符输出数据而建立的，则当作输入文件打开后，应使用提取操作符输入数据；若一个文件是使用put成员函数输出字符而建立的，则当作输入文件打开后，应使用get()或get(char&)成员函数输入字符数据；若每次需要从一个输入文件中读入一行字符时，则需要使用getline成员函数。
下面给出进行字符文件输入操作的几个例子。
例4. 从第1小节例1所建立的a:wr1.dat文件中输入全部数据并依次显示到屏幕上。
#include<iostream.h>
#include<stdlib.h>
#include<fstream.h>
void main(void)
{
ifstream f1("a:wr1.dat", ios::in | ios::nocreate);
//定义输入文件流，并打开相应文件，若打开失败则f1带回0值
if (!f1) { //当f1打开失败时进行错误处理
cerr<<"a:wr1.dat file not open!"<<endl;
exit(1);
}
int x;
while(f1>>x) //依次从文件中输入整数到x，
//当读到的是文件结束符时条件表达式的值为0
cout<<x<<' ';
cout<<endl;
f1.close(); //关闭f1所对应的文件
}
该程序运行结果如下：
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
例5. 从第1小节例2所建立的a:wr2.dat文件中按字符输入全部数据，把它们依次显示到屏幕上，并且统计出文件内容中的行数。
#include<iostream.h>
#include<stdlib.h>
#include<fstream.h>
void main(void)
{
ifstream f2("a:wr2.dat", ios::in | ios::nocreate);
if (!f2) {
cerr<<"a:wr2.dat file not open!"<<endl;
exit(1);
}
char ch; //用ch读入字符
int i=0; //用i统计行数
while(f2.get(ch)) //依次从文件中输入字符到ch，当读到的是文件
//结束符时条件表达式的值为0。
{
cout<<ch;
if(ch=='\n') i++;
}
cout<<endl<<"lines: "<<i<<endl;
f2.close(); //关闭f1所对应的文件
}
若把while语句中的条件表达式(f2.get(ch))换为(ch=f2.get())!=EOF)完全相同。该程序运行后的显示结果如下：
12345
asdfghj ghjk
wqreqwrew
lines: 3
其中前三行字符就是建立文件时从键盘上输入的文本，在此被原原本本地显示出来。
四、字符串流
字符串流类包括输入字符串流类istrstream,输出字符串流类ostrstream和输入输出字符串流类strstream三种。它们都被定义在系统头文件strstrea.h中。只要在程序中带有该头文件，就可以使用任一种字符串流类定义字符串流对象。每个字符串流对象简称为字符串流。
字符串流对应的访问空间是内存中由用户定义的字符数组，而文件流对应的访问空间是外存上由文件名确定的文件存储空间。由于字符串流和文件流都是输入流类istream和输出流类ostream的继承类，所以对它们的操作方法基本相同。但仍有一点区别：就是每个文件都有文件结束符标志，利用它可以判断读取数据是否到达文件尾，而字符串流所对应的字符数组中没有相应的结束符标志，这只能靠用户规定一个特殊字符作为其结束符使用，在向字符串流对应的字符数组写入正常数据后，再写入它表示结束。
每一种字符串流类都不带有open成员函数，所以只有在定义字符串流的同时给出必要的参数，通过自动调用相应的构造函数来使之与一个字符数组发生联系，以后对字符串流的操作实质上就是在该数组上进行的，就象对文件流的操作实质上就是在对应文件上进行的情况一样。三种字符串流类的构造函数声明格式分别如下：
istrstream(const char* buffer);
ostrstream(char* buffer, int n);
strstream(char* buffer, int n, int mode);
调用第一种构造函数建立的是输入字符串流，对应的字符数组空间由buffer指针所指向。调用第二种构造函数建立的是输出字符串流，对应的字符数组空间同样由buffer指针所指向，该空间的大小（即字节数）由参数表中第二个参数给出。调用第三种构造函数建立的是输入输出字符串流，其中第一个参数指定对应的字符数组存储空间，第二个参数指定空间的大小，第三个参数指定打开方式。一个字符串流被定义后就可以调用相应的成员函数进行数据的输入、输出操作，就如同使用文件流调用相应的成员函数进行有关操作一样。下面给出定义相应字符串流的例子。
(1) ostrstream sout(a1,50);
(2) istrstream sin(a2);
(3) strstream sio(a3,sizeof(a3),ios::in | ios::out);
第(1)条语句定义了一个输出字符串流sout，使用的字符数组为a1，大小为50个字节，以后对sout的输出都将被写入到字符数组a1中。第(2)条语句定义了一个输入字符串流sin，使用的字符数组为a2，以后从sin中读取的输入数据都将来自字符数组a2中。第(3)条语句定义了一个输入输出字符串流sio，使用的字符数组为a3，大小为a3数组的长度，打开方式规定为既能够用于输入又能够用于输出，当然进行输入的数据来自数组a3，进行输出的数据写入数组a3。
对字符串流的操作方法通常与对字符文件流的操作方法相同。下面给出一些使用字符串流的例子。
例1. 从一个字符串流中输入用逗号分开的每一个整数并显示出来。
#include<strstrea.h>
void main()
{
char a[]="38,46 ,55, 78,42 ,77,60,93@";
cout<<a<<endl; //输出a字符串
istrstream sin(a);
//定义一个输入字符串流sin，使用的字符数组为a
char ch=' ';
int x;
while(ch!='@') { //使用'@'字符作为字符串流结束标志
sin>>ws>>x>>ws;
//从流中读入一个整数，并使用操作符ws读取
//一个整数前后的空白字符
cout<<x<<' ';
//输出x的值并后跟一个空格
sin.get(ch);
//从sin流中读入一个字符，实际读取的是’,’或’@’字符
}
cout<<endl;
}
该程序运行结果如下：
38,46 ,55, 78,42 ,77,60,93@
38 46 55 78 42 77 60 93
例2. 从一个字符串中得到每一个整数，并把它们依次存入到一个字符串流中，最后向屏幕输出这个字符串流。
分析：假定待处理的一个字符串是从键盘上输入得到的，把它存入到字符数组a中，并且要把a定义为一个输入字符串流sin，还需要定义一个输出字符串流sout，假定对应的字符数组为b，用它保存依次从输入流中得到的整数。该程序的处理过程需要使用一个while循环，每次从sin流中得到一个整数，并把它输出到sout流中。然后要向sout流中输出一个作为字符串流结束符使用的特殊字符（假定为’@’）和字符串结束符’\0’。最后向屏幕输出sout流所对应的字符串。整个程序如下：
#include<strstrea.h>
void main()
{
char a[50];
char b[50];
istrstream sin(a);
//定义一个输入字符串流sin，使用的字符数组为a
ostrstream sout(b,sizeof(b));
//定义一个输出字符串流sout，使用的字符数组为b
cin.getline(a,sizeof(a));
//假定从键盘上输入的字符串为：
//"ab38+56,46*55-23/ad663,WER40ff:dy{63;44}@"
char ch=' ';
int x;
while(ch!='@') { //使用'@'字符作为字符串流结束标志
if(ch>=48 && ch<=57) {
sin.putback(ch); //把刚读入的一个数字压回流中。
sin>>x; //从流中读入一个整数，当碰到非数字字
//符时则就认为一个整数结束。
sout<<x<<' ';
//将x输出到字符串流sout中
}
sin.get(ch);
//从sin流中读入下一个字符
}
sout<<'@'<<ends; //向sout流输出作为结束符的'@'字符和
//一个字符串结束符'\0'
cout<<b; //输出字符串流sout对应的字符串
cout<<endl;
}
该程序的运行结果如下：
ab38+56,46*55-23/ad663,WER40ff:dy{63;44}@
38 56 46 55 23 663 40 63 44 @
评论