文件I/O

文件I/O 操作主要有以下几种：

1.文件输入流 ifstream

2.文件输出流 ofstream

3.文件输入输出流 fstream

4.文件的打开方式

5.文件流的状态

6.文件流的定位：文件指针（输入指针、输出指针）

7.文本文件和二进制文件

文件流类和文件流对象

输入输出是以系统指定的标准设备（输入设备为键盘，输出设备为显示器）为对象的。在实际应用中，常以磁盘文件作为对象。即从磁盘文件读取数据，将数据输出到磁盘文件。

和文件有关系的输入输出类主要在fstream.h这个头文件中被定义，在这个头文件中主要被定义了三个类，由这三个类控制对文件的各种输入输出操 作，他们分别是ifstream、ofstream、fstream，其中fstream类是由iostream类派生而来，他们之间的继承关系见下图所示。

由于文件设备并不像显示器屏幕与键盘那样是标准默认设备，所以它在fstream.h头文件中是没有像cout那样预先定义的全局对象，所以我们必须自己定义一个该类的对象。

ifstream类，它是从istream类派生的，用来支持从磁盘文件的输入。

ofstream类，它是从ostream类派生的，用来支持向磁盘文件的输出。

fstream类，它是从iostream类派生的，用来支持对磁盘文件的输入输出。

一、C++文件的打开与关闭

打开文件

所谓打开(open)文件是一种形象的说法，如同打开房门就可以进入房间活动一样。 打开文件是指在文件读写之前做必要的准备工作，包括：

1）为文件流对象和指定的磁盘文件建立关联，以便使文件流流向指定的磁盘文件。

2）指定文件的工作方式，如，该文件是作为输入文件还是输出文件，是ASCII文件还是二进制文件等。

以上工作可以通过两种不同的方法实现。

1) 调用文件流的成员函数open。如

    ofstream outfile;  //定义ofstream类(输出文件流类)对象outfile

    outfile.open("f1.dat",ios::out);  //使文件流与f1.dat文件建立关联

第2行是调用输出文件流的成员函数open打开磁盘文件f1.dat，并指定它为输出文件， 文件流对象outfile将向磁盘文件f1.dat输出数据。ios::out是I/O模式的一种，表示以输出方式打开一个文件。或者简单地说，此时f1.dat是一个输出文件，接收从内存输出的数据。

调用成员函数open的一般形式为：

    文件流对象.open(磁盘文件名, 输入输出方式);

磁盘文件名可以包括路径，如"c: ew\f1.dat"，如缺省路径，则默认为当前目录下的文件。

2) 在定义文件流对象时指定参数

在声明文件流类时定义了带参数的构造函数，其中包含了打开磁盘文件的功能。因此，可以在定义文件流对象时指定参数，调用文件流类的构造函数来实现打开文件的功能。如

    ostream outfile("f1.dat",ios::out); 一般多用此形式，比较方便。作用与open函数相同。

输入输出方式是在ios类中定义的，它们是枚举常量，有多种选择，见表13.6。

注意几点说明：
1) 新版本的I/O类库中不提供ios::nocreate和ios::noreplace。
2) 每一个打开的文件都有一个文件指针，该指针的初始位置由I/O方式指定，每次读写都从文件指针的当前位置开始。每读入一个字节，指针就后移一个字节。当文 件指针移到最后，就会遇到文件结束EOF（文件结束符也占一个字节，其值为-1)，此时流对象的成员函数eof的值为非0值(一般设为1)，表示文件结束 了。
3) 可以用“位或”运算符“|”对输入输出方式进行组合，如表13.6中最后3行所示那样。还可以举出下面一些例子：
    ios::in | ios:: noreplace  //打开一个输入文件，若文件不存在则返回打开失败的信息
    ios::app | ios::nocreate  //打开一个输出文件，在文件尾接着写数据，若文件不存在，则返回打开失败的信息
    ios::out l ios::noreplace  //打开一个新文件作为输出文件，如果文件已存在则返回打开失败的信息
    ios::in l ios::out I ios::binary  //打开一个二进制文件，可读可写
但不能组合互相排斥的方式，如 ios::nocreate l ios::noreplace。
4) 如果打开操作失败，open函数的返回值为0(假)，如果是用调用构造函数的方式打开文件的，则流对象的值为0。可以据此测试打开是否成功。如
    if(outfile.open("f1.bat", ios::app) ==0)
        cout <<"open error";
或
    if( !outfile.open("f1.bat", ios::app) )
        cout <<"open error";

关闭文件

在对已打开的磁盘文件的读写操作完成后，应关闭该文件。关闭文件用成员函数close。如
    outfile.close( );  //将输出文件流所关联的磁盘文件关闭
所谓关闭，实际上是解除该磁盘文件与文件流的关联，原来设置的工作方式也失效，这样，就不能再通过文件流对该文件进行输入或输出。此时可以将文件流与其他磁盘文件建立关联，通过文件流对新的文件进行输入或输出。如
    outfile.open("f2.dat",ios::app|ios::nocreate);
此时文件流outfile与f2.dat建立关联，并指定了f2.dat的工作方式。

二、C++对ASCII文件的读写操作

如果文件的每一个字节中均以ASCII代码形式存放数据,即一个字节存放一个字符,这个文件就是ASCII文件(或称字符文件)。程序可以从ASCII文件中读入若干个字符,也可以向它输出一些字符。

　　1) 用流插入运算符“<<”和流提取运算符“>>”输入输出标准类型的数据。“<<”和“ >>”都巳在iostream中被重载为能用于ostream和istream类对象的标准类型的输入输出。由于ifstream和 ofstream分别是ostream和istream类的派生类；因此它们从ostream和istream类继承了公用的重载函数，所以在对磁盘文件的操作中，可以通过文件流对象和流插入运算符“<<”及 流提取运算符“>>”实现对磁盘 文件的读写，如同用cin、cout和<<、>>对标准设备进行读写一样。

　　2)  用文件流的put、get、geiline等成员函数进行字符的输入输出，：用C++流成员函数put输出单个字符、C++ get()函数读入一个字符和C++ getline()函数读入一行字符。

案例1：写文件，然后读文件

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

int main92()
{
	char fileName[80];
	char buffer[255];

	cout << "请输入一个文件名: ";
	cin >> fileName;

	ofstream fout(fileName, ios::app);
	fout << "1111111111111111111
";
	fout << "22222222222222222
";
	//cin.ignore(1,'
');
	cin.getline(buffer,255); //从键盘输入
	fout << buffer << "
";
	fout.close();

	ifstream fin(fileName);
	cout << "Here's the the content of the file: 
";
	char ch;
	while(fin.get(ch))
		cout << ch;

	cout << "
***End of file contents.***
";
	fin.close();
	system("pause");
	return 0;
}

　　

案例2

ofstream类的默认构造函数原形为：

ofstream::ofstream(constchar *filename, int mode = ios::out,

 int penprot = filebuf::openprot);

 

• filename：　　要打开的文件名
• mode：　　　　要打开文件的方式
• prot：　　　　打开文件的属性

　　其中mode和openprot这两个参数的可选项表见下表：

mode属性表
ios::app	以追加的方式打开文件
ios::ate	文件打开后定位到文件尾，ios:app就包含有此属性
ios::binary	以二进制方式打开文件，缺省的方式是文本方式。两种方式的区别见前文
ios::in	文件以输入方式打开
ios::out	文件以输出方式打开
ios::trunc	如果文件存在，把文件长度设为0

注意：可以用“|”把以上属性连接起来，如ios::out|ios::binary。

openprot属性表
属性	含义
0	普通文件，打开访问
1	只读文件
2	隐含文件
4	系统文件

注意：可以用“或”或者“+”把以上属性连接起来 ，如3或1|2就是以只读和隐含属性打开文件。

#include <fstream> 
usingnamespace std; 

int main()  
{ 
        ofstream myfile("c:\1.txt",ios::out|ios::trunc,0); 
        myfile<<"gd_无痕"<<endl<<"网址："<<"https://i.cnblogs.com"; 
        myfile.close() 
        system("pause"); 
}

　　

文件使用完后可以使用close成员函数关闭文件。

　　ios::app为追加模式，在使用追加模式的时候同时进行文件状态的判断是一个比较好的习惯。

#include <iostream> 
#include <fstream> 
usingnamespace std; 
int main()  
{ 
        ofstream myfile("c:\1.txt",ios::app,0); 
        if(!myfile)//或者写成myfile.fail() 
        { 
                cout<<"文件打开失败，目标文件状态可能为只读！"; 
                system("pause"); 
                exit(1); 
        } 
        myfile<<"gd_无痕"<<endl<<"网址："<<"https://i.cnblogs.com"<<endl; 
　　　　 myfile.close()；

}

　　

在定义ifstream和ofstream类对象的时候，我们也可以不指定文件。以后可以通过成员函数open()显式的把一个文件连接到一个类对象上。

#include <iostream> 
#include <fstream> 
usingnamespace std; 
int main()  
{ 
        ofstream myfile; 
        myfile.open("c:\1.txt",ios::out|ios::app,0); 
        if(!myfile)//或者写成myfile.fail() 
        { 
                cout<<"文件创建失败,磁盘不可写或者文件为只读!"; 
                system("pause"); 
                exit(1); 
        }

  　　　 myfile<<"gd_无痕"<<endl<<"网址："<<"https://i.cnblogs.com"; 
        myfile.close() 
        system("pause"); 

}

下面来看一下是如何利用ifstream类对象，将文件中的数据读取出来，然后再输出到标准设备中的例子。

#include <iostream> 
#include <fstream> 
#include <string> 
usingnamespace std; 
int main()  
{ 
        ifstream myfile; 
        myfile.open("c:\1.txt",ios::in,0); 
        if(!myfile) 
        { 
                cout<<"文件读错误"; 
                system("pause"); 
                exit(1); 
        } 
        char ch; 
        string content; 
        while(myfile.get(ch)) 
        { 
                content+=ch; 
                cout.put(ch);//cout<<ch;这么写也是可以的 
        } 
        myfile.close(); 
        cout<<content; 
        system("pause"); 
}

上例中，利用成员函数get()，逐一的读取文件中的有效字符，再利用put()成员函数，将文件中的数据通过循环逐一输出到标准设备(屏幕) 上， get()成员函数会在文件读到默尾的时候返回假值，所以我们可以利用它的这个特性作为while循环的终止条件，我们同时也在上例中引入了C++风格的 字符串类型string，在循环读取的时候逐一保存到content中，要使用string类型，必须包含string.h的头文件。

 

在简单介绍过ofstream类和ifstream类后，再来看一下fstream类，fstream类是由iostream派生而来，fstream类对象可以同对文件进行读写操作。#include

#include <iostream> 
#include <fstream> 
usingnamespace std; 

int main()  
{ 
        fstream myfile; 
        myfile.open("c:\1.txt",ios::out|ios::app,0); 
        if(!myfile) 
        { 
                cout<<"文件写错误,文件属性可能为只读!"<<endl; 
                system("pause"); 
                exit(1); 
        } 
        myfile<<"gd_无痕"<<endl<<"网址："<<"https://i.cnblogs.com”;   
　　　　 myfile.close(); 

        myfile.open("c:\1.txt",ios::in,0); 
        if(!myfile) 
        { 
                cout<<"文件读错误,文件可能丢失!"<<endl; 
                system("pause"); 
                exit(1); 
        } 
        char ch; 
        while(myfile.get(ch)) 
        { 
                cout.put(ch); 
        } 
        myfile.close(); 
        system("pause"); 
}

由于fstream类可以对文件同时进行读写操作，所以对它的对象进行初始话的时候一定要显式的指定mode和openprot参数。

 

 三、C++对二进制文件的读写操作

　　二进制文件不是以ASCII代码存放数据的，它将内存中数据存储形式不加转换地传送到磁盘文件，因此它又称为内存数据的映像文件。因为文件中的信息不是字符数据，而是字节中的二进制形式的信息，因此它又称为字节文件。

　　对二进制文件的操作也需要先打开文件，用完后要关闭文件。在打开时要用ios::binary指定为以二进制形式传送和存储。二进制文件除了可以作为输入文件或输出文件外,还可以是既能输入又能输出的文件。这是和ASCII文件不同的地方。

用成员函数read和write读写二进制文件

对二进制文件的读写主要用istream类的成员函数read和write来实现。这两个成员函数的原型为
    istream& read(char *buffer,int len);
    ostream& write(const char * buffer,int len);
字符指针buffer指向内存中一段存储空间。len是读写的字节数。调用的方式为：
    a. write(p1,50);
    b. read(p2,30);
上面第一行中的a是输出文件流对象，write函数将字符指针p1所给出的地址开始的50个字节的内容不加转换地写到磁盘文件中。在第二行中，b是输入文 件流对象，read 函数从b所关联的磁盘文件中，读入30个字节(或遇EOF结束），存放在字符指针p2所指的一段空间内。

案例

int main()
{
	char fileName[255] = "c:/teacher.dat";
	ofstream fout(fileName,ios::binary);
	if(!fout)
	{
		cout << "Unable to open " << fileName << " for writing.
";
		return(1);
	}

	Teacher t1(31, "31");
	Teacher t2(32, "32");
	fout.write((char *)&t1,sizeof Teacher);
	fout.write((char *)&t2,sizeof Teacher);
	fout.close();

	cout << "保存对象到二进制文件里成功!" << endl;

	ifstream fin(fileName,ios::binary);
	if(!fin)
	{
		cout << "Unable to open " << fileName << " for reading.
";
		return (1);
	}
	Teacher tmp(100,"100");

	fin.read((char *)&tmp,sizeof Teacher);
	tmp.printT();
	fin.read((char *)&tmp,sizeof Teacher);
	tmp.printT();
	system("pause");

	return 0;
}

练习

1 编程实现以下数据输入/输出：

    (1)以左对齐方式输出整数,域宽为12。

    (2)以八进制、十进制、十六进制输入/输出整数。

    (3)实现浮点数的指数格式和定点格式的输入/输出,并指定精度。

    (4)把字符串读入字符型数组变量中,从键盘输入,要求输入串的空格也全部读入,以回车符结束。

    (5)将以上要求用流成员函数和操作符各做一遍。

2编写一程序，将两个文件合并成一个文件。

3编写一程序，统计一篇英文文章中单词的个数与行数。

4编写一程序，将C++源程序每行前加上行号与一个空格。

4.5编写一程序，输出 ASCII码值从20到127的ASCII码字符表，格式为每行10个。

 

第一题
Ios类成员函数实现
#include<iostream>
#include<iomanip>
using namespace std;
int main(){
	long a=234;
	double b=2345.67890;
	char c[100];
	cout.fill('*');
	cout.flags(ios_base::left);
	cout.width(12);
	cout<<a<<endl;
	cout.fill('*');
	cout.flags(ios::right);
	cout.width(12);
	cout<<a<<endl;
	cout.flags(ios.hex);
	cout<<234<<'	';
	cout.flags(ios.dec);
	cout<<234<<'	';
	cout.flags(ios.oct);
	cout<<234<<endl;
	cout.flags(ios::scientific);
	cout<<b<<'	';
	cout.flags(ios::fixed);
	cout<<b<<endl;
	cin.get(c,99);
	cout<<c<<endl;
	return 0;
}
操作符实现
#include<iostream>
#include<iomanip>
using namespace std;
int main(){
	long a=234;
	double b=2345.67890;
	char c[100];
	cout<<setfill('*');
	cout<<left<<setw(12)<<a<<endl;
	cout<<right<<setw(12)<<a<<endl;
	cout<<hex<<a<<'	'<<dec<<a<<'	'<<oct<<a<<endl;
	cout<<scientific<<b<<'	'<<fixed<<b<<endl;
	return 0;
}

第二题

#include<iostream>
#include<fstream>
using namespace std;
int main(){
	int i=1;
	char c[1000];
	ifstream ifile1("D:\1.cpp");
	ifstream ifile2("D:\2.cpp");
	ofstream ofile("D:\3.cpp");
	while(!ifile1.eof()){
		ifile1.getline(c,999);
		ofile<<c<<endl;
	}
	while(!ifile2.eof()){
		ifile2.getline(c,999);
		ofile<<c<<endl;
	}
	ifile1.close();
	ifile2.close();
	ofile.close();
	return 0;
}

第三题

#include<iostream>
#include<fstream>
using namespace std;
bool isalph(char);
int main(){
	ifstream ifile("C:\daily.doc");
	char text[1000];
	bool inword=false;
	int rows=0,words=0;
	int i;
	while(!ifile.eof()){
		ifile.getline(text,999);
		rows++;
		i=0;
		while(text[i]!=0){
			if(!isalph(text[i]))
				inword=false;
			else if(isalph(text[i]) && inword==false){
				words++;
				inword=true;
			}
			i++;
		}
	}
	cout<<"rows= "<<rows<<endl;
	cout<<"words= "<<words<<endl;
	ifile.close ();
	return 0;
}
bool isalph(char c){
	return ((c>='A' && c<='Z') || (c>='a' && c<='z'));
}

　

第四题

#include<iostream>
#include<fstream>
using namespace std;
int main(){
	int i=1;
	char c[1000];
	ifstream ifile("D:\1.cpp");
	ofstream ofile("D:\2.cpp");
	while(!ifile.eof()){
		ofile<<i++<<": ";
		ifile.getline(c,999);
		ofile<<c<<endl;
	}
	ifile.close();
	ofile.close();
	return 0;
}

　　

第五题

#include<iostream>
using namespace std;
int main(){
	int i,l;
	for(i=32;i<127;i++){
		cout<<char(i)<<" ";
		l++;
		if(l%10==0)cout<<endl;
	}
	cout<<endl;
	return 0;
}