2019 March 15 CPP基础

第十三章 I/O流

C++输入和输出流

I/O流的概念和流类库的结构

  1. 程序的输入指的是从输入文件将数据传送给程序，程序的输出指的是从程序将数据传送给输出文件。
  2. C++输入输出包含以下三个方面的内容：
    1. 对系统指定的标准设备的输入和输出。即从键盘输入数据，输出到显示器屏幕。这种输入输出称为标准的输入输出，简称标准I/O。
    2. 以外存磁盘文件为对象进行输入和输出，即从磁盘文件输入数据，数据输出到磁盘文件。以外存文件为对象的输入输出称为文件的输入输出，简称文件I/O。
    3. 对内存中指定的空间进行输入和输出。通常指定一个字符数组作为存储空间(实际上可以利用该空间存储任何信息)。这种输入和输出称为字符串输入输出，简称串I/O。
  3. C++的I/O对C的发展–类型安全和可扩展性
    1. 在C语言中，用printf和scanf进行输入输出，往往不能保证所输入输出的数据是可靠的安全的。
    2. 在C++的输入输出中，编译系统对数据类型进行严格的检查，凡是类型不正确的数据都不可能通过编译。因此C++的I/O操作是类型安全(type safe)的。
    3. C++的I/O操作是可扩展的，不仅可以用来输入输出标准类型的数据，也可以用于用户自定义类型的数据。
    4. C++通过I/O类库来实现丰富的I/O功能。这样使C++的输人输出明显地优于C 语言中的printf和scanf，但是也为之付出了代价，C++的I/O系统变得比较复杂，要掌握许多细节

    5. C++编译系统提供了用于输入输出的iostream类库。iostream这个单词是由3个部 分组成的，即i-o-stream，意为输入输出流。在iostream类库中包含许多用于输入输出的 类。常用的见表

      图1

      1. ios是抽象基类，由它派生出istream类和ostream类，两个类名中第1个字母i和o分别代表输入(input)和输出(output)。
      2. istream类支持输入操作，ostream类支持输出操作， iostream类支持输入输出操作。
      3. iostream类是从istream类和ostream类通过多重继承而派生的类。其继承层次见上图表示。
      4. C++对文件的输入输出需要用ifstrcam和ofstream类，两个类名中第1个字母i和o分别代表输入和输出，第2个字母f代表文件 (file)。
      5. ifstream支持对文件的输入操作， ofstream支持对文件的输出操作。

      6. 类ifstream继承了类istream，类ofstream继承了类ostream，类fstream继承了 类iostream。

        图1

    6. I/O类库中还有其他一些类，但是对于一般用户来说，以上这些已能满足需要了
  4. 与iostream类库有关的头文件
    1. iostream类库中不同的类的声明被放在不同的头文件中，用户在自己的程序中用#include命令包含了有关的头文件就相当于在本程序中声明了所需 要用到的类。可以换 —种说法：头文件是程序与类库的接口，iostream类库的接口分别由不同的头文件来实现。
    2. 常用的有
      1. iostream  包含了对输入输出流进行操作所需的基本信息。
      2. fstream  用于用户管理的文件的I/O操作。
      3. strstream  用于字符串流I/O。
      4. stdiostream  用于混合使用C和C + +的I/O机制时，例如想将C程序转变为C++程序。
      5. iomanip  在使用格式化I/O时应包含此头文件。
  5. 在iostream头文件中定义的流对象
    1. 在 iostream 头文件中定义的类有 ios，istream，ostream，iostream，istream _withassign， ostream_withassign，iostream_withassign 等。

    2. 在iostream头文件中不仅定义了有关的类，还定义了4种流对象， 图1

      1. 在iostream头文件中定义以上4个流对象用以下的形式（以cout为例）: ostream cout ( stdout);
      2. 在定义cout为ostream流类对象时，把标准输出设备stdout作为参数，这样它就与标准输出设备(显示器)联系起来，如果有cout <<3; 就会在显示器的屏幕上输出3。
  6. 在iostream头文件中重载运算符
    1. “«”和“»”本来在C++中是被定义为左位移运算符和右位移运算符的，由于在iostream头文件中对它们进行了重载， 使它们能用作标准类型数据的输入和输出运算符。所以，在用它们的程序中必须用#include命令把iostream包含到程序中。#include <iostream>
    2. >>a表示将数据放入a对象中。
    3. <<a表示将a对象中存储的数据拿出。

标准I/O流

  1. 标准I/O对象:cin，cout，cerr，clog
  2. cout流对象
    1. cont是console output的缩写，意为在控制台（终端显示器）的输出。强调几点。
      1. cout不是C++预定义的关键字，它是ostream流类的对象，在iostream中定义。 顾名思义，流是流动的数据，cout流是流向显示器的数据。cout流中的数据是用流插入运算符“«”顺序加入的。如果有cout<<"I "<<"study C++ "<<"very hard. << “wang bao ming ";按顺序将字符串”I “, “study C++ “, “very hard.”插人到cout流中，cout就将它们送到显示器，在显示器上输出字符串”I study C++ very hard.“。cout流是容纳数据的载体，它并不是一个运算符。人们关心的是cout流中的内容，也就是向显示器输出什么。
      2. 用“cout«”输出基本类型的数据时，可以不必考虑数据是什么类型，系统会判断数据的类型，并根据其类型选择调用与之匹配的运算符重 载函数。这个过程都是自动的，用户不必干预。如果在C语言中用prinf函数输出不同类型的数据，必须分别指定相应的输出格式符，十分麻烦，而且容易出 错。C++的I/O机制对用户来说，显然是方便而安全的。
      3. cout流在内存中对应开辟了一个缓冲区，用来存放流中的数据，当向cout流插 人一个endl时，不论缓冲区是否已满，都立即输出流中所有数据，然后插入一个换行符， 并刷新流（清空缓冲区）。注意如果插人一个换行符”\n“（如cout«a«“\n”），则只输出和换行，而不刷新cout 流(但并不是所有编译系统都体现出这一区别）。
      4. 在iostream中只对”«“和”»“运算符用于标准类型数据的输入输出进行了重载，但未对用户声明的类型数据的输入输出 进行重载。如果用户声明了新的类型，并希望用”«“和”»“运算符对其进行输入输出，按照重运算符重载来做。
    2. cerr流对象
      1. cerr流对象是标准错误流，cerr流已被指定为与显示器关联。
      2. cerr的 作用是向标准错误设备(standard error device)输出有关出错信息。
      3. cerr与标准输出流cout的作用和用法差不多。但有一点不同：cout流通常是传送到显示器输出，但也可以被重定向 输出到磁盘文件，而cerr流中的信息只能在显示器输出。
      4. 当调试程序时，往往不希望程序运行时的出错信息被送到其他文件，而要求在显示器上及时输出，这时 应该用cerr。cerr流中的信息是用户根据需要指定的。
    3. clog流对象
      1. clog流对象也是标准错误流，它是console log的缩写。它的作用和cerr相同，都是在终端显示器上显示出错信息。
      2. 区别：cerr是不经过缓冲区，直接向显示器上输出有关信息，而clog中的信息存放在缓冲区中，缓冲区满后或遇endl时向显示器输出。

    4. 缓冲区的概念

      图1

标准输入流

  1. 标准输入流对象cin，重点掌握的函数

     cin.get() //一次只能读取一个字符
 cin.get(一个参数) //读一个字符
 cin.get(三个参数) //可以读字符串
 cin.getline()
 cin.ignore()
 cin.peek()
 cin.putback()

  2. 标准输入流常见api编程案例

     //1 cin cout能根据类型 获取数据 / 输出数据
 //2 输入字符串 你 好  遇见空格,停止接受输入
 void main01()
 {
 	char YourName[50];
 	int myInt;
 	long myLong;
 	double myDouble;
 	float myFloat;
 	unsigned int myUnsigned;
    
 	cout << "请输入一个Int: ";
 	cin >> myInt;
 	cout << "请输入一个Long: ";
 	cin >> myLong;
 	cout << "请输入一个Double: ";
 	cin >> myDouble;
    
 	cout << "请输入你的姓名: ";
 	cin >> YourName;
    
 	cout << "\n\n你输入的数是：" << endl;
 	cout << "Int: \t" << myInt << endl;
 	cout << "Long: \t" << myLong << endl;
 	cout << "Double: \t" << myDouble << endl;
 	cout << "姓名: \t" << YourName << endl;
 	cout<< endl << endl;
 	system("pause");
 	return ;
 }
    
 //1 输入英文 ok 
 //2 ctr+z  会产生一个 EOF(-1)
 int main02()
 {
 	char ch;
 	while( (ch= cin.get())!= EOF)
 	{
 		std::cout << "字符: " << ch << std::endl;
 	}
 	std::cout << "\n结束.\n";
 	system("pause");
 	return 0;
 }
    
 //演示:读一个字符 链式编程
 void main03()
 {
 	char a, b, c;
 	cin.get(a);
 	cin.get(b);
 	cin.get(c);
 	cout << a << b << c<< endl;
    
 	cout << "开始链式编程" << endl;
 	cout.flush();
    
 	cin.get(a).get(b).get(c);
 	cout << a << b << c<< endl;
 	system("pause");
 	return ;
 }
    
    
 //演示cin.getline() 可以接受空格
 void main04()
 {
 	char buf1[256];
 	char buf2[256]; 
 	cout << "\n请输入你的字符串 不超过256" ;
 	cin.getline(buf1, 256, '\n'); 
 	cout << buf1 << endl;
    
 	// 
 	cout << "注意: cin.getline() 和 cin >> buf2 的区别, 能不能带空格 " << endl;
 	cin >> buf2 ; //流提取操作符 遇见空格 停止提取输入流
 	cout << buf2 << endl;
 	system("pause");
 }
    
 //缓冲区实验 
 /*
 1 输入 "aa bb cc dd" 字符串入缓冲区 
 2 通过 cin >> buf1; 提走了 aa 
 3 不需要输入 可以再通过cin.getline() 把剩余的缓冲区数据提走
 */
 void main05()
 {
 	char buf1[256];
 	char buf2[256];
    
 	cout << "请输入带有空格的字符串,测试缓冲区" << endl; 
 	cin >> buf1;
 	cout << "buf1:" << buf1 << endl; 
    
 	cout << "请输入数据..." << endl;
    
 	//缓冲区没有数据,就等待; 缓冲区如果有数据直接从缓冲区中拿走数据
 	cin.getline(buf2, 256); 
 	cout << "buf2:" << buf2 << endl;
 	system("pause");
 }
    
 // ignore 和 peek
 void main06()
 {
 	int  intchar;
 	char buf1[256];
 	char buf2[256];
    
 	cout << "请输入带有空格的字符串,测试缓冲区 aa bb cc dd ee " << endl; 
 	cin >> buf1;
 	cout << "buf1:" << buf1 << endl; 
    
 	cout << "请输入数据..." << endl;
 	cin.ignore(2);
 	//intchar = cin.peek();
 	//cout << "缓冲区若有数据,返回第一个数据的asc码:" << intchar << endl;
    
 	//缓冲区没有数据,就等待; 缓冲区如果有数据直接从缓冲区中拿走数据
 	cin.getline(buf2, 256); 
 	cout << "buf2:" << buf2 << endl;
    
 	intchar = cin.peek(); //没有缓冲区 默认是阻塞模式 
 	cout << "缓冲区若有数据,返回第一个数据的asc码:" << intchar << endl;
 	system("pause");
 }
    
 //案例:输入的整数和字符串分开处理
 int main07() 
 {
 	cout << "Please, enter a number or a word: ";
 	char c = std::cin.get();
    
 	if ( (c >= '0') && (c <= '9') ) //输入的整数和字符串 分开处理
 	{
 		int n; //整数不可能 中间有空格 使用cin >>n
 		cin.putback (c);
 		cin >> n;
 		cout << "You entered a number: " << n << '\n';
 	}
 	else
 	{
 		string str;
 		cin.putback (c);
 		getline (cin,str); // //字符串 中间可能有空格 使用 cin.getline();
 		cout << "You entered a word: " << str << '\n';
 	}	system("pause");
 	return 0;
 }

标准输出流

  1. 标准输出流对象cout,重点掌握的函数

     cout.flush()
 cout.put()
 cout.write()
 cout.width()
 cout.fill()
 cout.setf(标记)

  2. 标准输出流常见api编程案例

     #include "iostream"
 using namespace std;
 #include <iomanip> 
    
 void main81()
 {
 	cout << "hello world" << endl;
 	cout.put('h').put('e').put('l').put('\n');
 	cout.write("hello world", 4); //输出的长度
    
 	char buf[] = "hello world";
 	printf("\n");
 	cout.write(buf, strlen(buf));
    
 	printf("\n");
 	cout.write(buf, strlen(buf) - 6);
    
 	printf("\n");
 	cout.write(buf, strlen(buf) + 6); //给的大于buf长度 不会帮我们检查 提高速度
    
 	printf("\n");
    	
 	system("pause");
 	return ;
 }
    
 //使用cout.setf()控制符
 void main82()
 {
 	//使用类成员函数
 	cout << "<start>";
 	cout.width(30);
 	cout.fill('*');
 	cout.setf(ios::showbase); //#include <iomanip>
 	cout.setf(ios::internal); //设置
 	cout << hex << 123 << "<End>\n";
    
 	cout << endl;
 	cout << endl;
 	//manipulator(操作符、控制符)
    
 	//使用控制阀
 	cout << "<Start>" 
 		<< setw(30) 
 		<< setfill('*') 
 		<< setiosflags(ios::showbase) //基数
 		<< setiosflags(ios::internal)
 		<< hex
 		<< 123
 		<< "<End>\n"
 		<< endl;
    
 	system("pause");
 }

  3. C++格式化输出，C++输出格式控制

    1. 在输出数据时，为简便起见，往往不指定输出的格式，由系统根据数据的类型采取默认的格式，但有时希望数据按指定的格式输出，如要求以十六进制或八进制形式 输出一个 整数，对输出的小数只保留两位小数等。有两种方法可以达到此目的。
      1. 使用控制符的方法；
      2. 使用流对象的有关成员函数。分别叙述如下。

    2. 使用控制符的方法：

       int main()
 {
 	int a;
 	cout<<"input a:";
 	cin>>a;
 	cout<<"dec:"<<dec<<a<<endl; //以十进制形式输出整数
 	cout<<"hex:"<<hex<<a<<endl; //以十六进制形式输出整数a
 	cout<<"oct:"<<setbase(8)<<a<<endl; //以八进制形式输出整数a
 	char *pt="China"; //pt指向字符串"China"
 	cout<<setw(10)<<pt<<endl; //指定域宽为,输出字符串
 	cout<<setfill('*')<<setw(10)<<pt<<endl; //指定域宽,输出字符串,空白处以'*'填充
 	double pi=22.0/7.0; //计算pi值
 	//按指数形式输出,8位小数
 	cout<<setiosflags(ios::scientific)<<setprecision(8);
 	cout<<"pi="<<pi<<endl; //输出pi值
 	cout<<"pi="<<setprecision(4)<<pi<<endl; //改为位小数
 	cout<<"pi="<<setiosflags(ios::fixed)<<pi<<endl; //改为小数形式输出
 	system("pause");
 	return 0;
 }
        
 运行结果如下：
        input a:34↙(输入a的值)
 dec:34                   (十进制形式)
 hex:22                   (十六进制形式)
 oct:42                   (八进制形式)
 China               (域宽为)
 *****China               (域宽为,空白处以'*'填充)
 pi=3.14285714e+00        (指数形式输出,8位小数)
 pi=3.1429e+00            (指数形式输出,4位小数)
 pi=3.143                 (小数形式输出,精度仍为)

      1. 人们在输入输出时有一些特殊的要求，如在输出实数时规定字段宽度，只保留两位小数，数据向左或向右对齐等。C++提供了在输入输出流中使用的控制符(有的书中称为操纵符)

        图1

        1. 举例， 输出双精度数：

           double a=123.456789012345;  // 对a赋初值 
 1) cout<<a;  输出： 123.456
 2) cout<<setprecision(9)<<a;  输出： 123.456789
 3) cout<<setprecision(6);  恢复默认格式(精度为6)
 4) cout<< setiosflags(ios∷fixed);  输出： 123.456789
 5) cout<<setiosflags(ios∷fixed)<<setprecision(8)<<a;  输出： 123.45678901
 6) cout<<setiosflags(ios∷scientific)<<a;  输出： 1.234568e+02
 7) cout<<setiosflags(ios∷scientific)<<setprecision(4)<<a;  输出： 1.2346e02

        2. 下面是整数输出的例子：

           int b=123456;  // 对b赋初值
 1) cout<<b;  输出： 123456
 2) cout<<hex<<b;   输出： 1e240
 3) cout<<setiosflags(ios∷uppercase)<<b;  输出： 1E240
 4) cout<<setw(10)<<b<<'，'<<b;   输出：  123456，123456
 5) cout<<setfill('*')<<setw(10)<<b;  输出： **** 123456
 6) cout<<setiosflags(ios∷showpos)<<b;  输出： +123456

    3. 用流对象的成员函数控制输出格式

       int main( )
 {
 	int a=21;
 	cout.setf(ios::showbase);//显示基数符号(0x或)
 	cout<<"dec:"<<a<<endl; //默认以十进制形式输出a
 	cout.unsetf(ios::dec); //终止十进制的格式设置
 	cout.setf(ios::hex); //设置以十六进制输出的状态
 	cout<<"hex:"<<a<<endl; //以十六进制形式输出a
 	cout.unsetf(ios::hex); //终止十六进制的格式设置
 	cout.setf(ios::oct); //设置以八进制输出的状态
 	cout<<"oct:"<<a<<endl; //以八进制形式输出a
 	cout.unsetf(ios::oct);
 	char *pt="China"; //pt指向字符串"China"
 	cout.width(10); //指定域宽为
 	cout<<pt<<endl; //输出字符串
 	cout.width(10); //指定域宽为
 	cout.fill('*'); //指定空白处以'*'填充
 	cout<<pt<<endl; //输出字符串
 	double pi=22.0/7.0; //输出pi值
 	cout.setf(ios::scientific); //指定用科学记数法输出
 	cout<<"pi="; //输出"pi="
 	cout.width(14); //指定域宽为
 	cout<<pi<<endl; //输出pi值
 	cout.unsetf(ios::scientific); //终止科学记数法状态
 	cout.setf(ios::fixed); //指定用定点形式输出
 	cout.width(12); //指定域宽为
 	cout.setf(ios::showpos); //正数输出“+”号
 	cout.setf(ios::internal); //数符出现在左侧
 	cout.precision(6); //保留位小数
 	cout<<pi<<endl; //输出pi,注意数符“+”的位置
 	system("pause");
 	return 0;
 }
 运行情况如下：
 dec:21(十进制形式)
 hex:0x15                 (十六进制形式,以x开头)
 oct:025                  (八进制形式,以开头)
 China               (域宽为)
 *****China               (域宽为,空白处以'*'填充)
 pi=**3.142857e+00        (指数形式输出,域宽,默认位小数)
 +***3.142857             (小数形式输出,精度为,最左侧输出数符“+”)

文件I/O

  1. 文件输入流 ifstream
  2. 文件输出流 ofstream
  3. 文件输入输出流 fstream
  4. 文件的打开方式
  5. 文件流的状态
  6. 文件流的定位：文件指针（输入指针、输出指针）
  7. 文本文件和二进制文件

文件流类和文件流对象

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

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

    图1

    1. 由于文件设备并不像显示器屏幕与键盘那样是标准默认设备，所以它在fstream.h头文件中是没有像cout那样预先定义的全局对象，所以我们必须自己定义一个该类的对象。
    2. ifstream类，它是从istream类派生的，用来支持从磁盘文件的输入
    3. ofstream类，它是从ostream类派生的，用来支持向磁盘文件的输出。
    4. fstream类，它是从iostream类派生的，用来支持对磁盘文件的输入输出。

C++文件的打开与关闭

  1. 打开文件
    1. 所谓打开(open)文件是一种形象的说法，如同打开房门就可以进入房间活动一样。 打开文件是指在文件读写之前做必要的准备工作，包括：
      1. 为文件流对象和指定的磁盘文件建立关联，以便使文件流流向指定的磁盘文件。
      2. 指定文件的工作方式，如，该文件是作为输入文件还是输出文件，是ASCII文件还是二进制文件等。
    2. 以上工作可以通过两种不同的方法实现。

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

         ofstream outfile;  //定义ofstream类(输出文件流类)对象outfile
 outfile.open("f1.dat",ios::out);  //使文件流与f1.dat文件建立关联
        1. 第2行是调用输出文件流的成员函数open打开磁盘文件f1.dat，并指定它为输出文件， 文件流对象outfile将向磁盘文件f1.dat输出数据。ios::out是I/O模式的一种，表示以输出方式打开一个文件。或者简单地说，此时f1.dat是一个输出文件，接收从内存输出的数据。
        2. 调用成员函数open的一般形式为：
          1. 文件流对象.open(磁盘文件名, 输入输出方式);
            1. 文件流对象.open(磁盘文件名, 输入输出方式);
          2. 磁盘文件名可以包括路径，如”c:\new\f1.dat”，如缺省路径，则默认为当前目录下的文件。

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

        1. 在声明文件流类时定义了带参数的构造函数，其中包含了打开磁盘文件的功能。因此，可以在定义文件流对象时指定参数，调用文件流类的构造函数来实现打开文件的功能。如 ostream outfile("f1.dat",ios::out); 一般多用此形式，比较方便。作用与open函数相同。
        2. 输入输出方式是在ios类中定义的，它们是枚举常量，有多种选择，见表13.6。 图1
        3. 几点说明：
          1. 新版本的I/O类库中不提供ios::nocreate和ios::noreplace。
          2. 每一个打开的文件都有一个文件指针，该指针的初始位置由I/O方式指定，每次读写都从文件指针的当前位置开始。每读入一个字节，指针就后移一个字节。当文 件指针移到最后，就会遇到文件结束EOF（文件结束符也占一个字节，其值为-1)，此时流对象的成员函数eof的值为非0值(一般设为1)，表示文件结束 了。
          3. 可以用“位或”运算符“ ”对输入输出方式进行组合，如表13.6中最后3行所示那样。还可以举出下面一些例子：(但不能组合互相排斥的方式，如 ios::nocreate l ios::noreplace。) 
             ios::in | ios:: noreplace  //打开一个输入文件，若文件不存在则返回打开失败的信息
 ios::app | ios::nocreate  //打开一个输出文件，在文件尾接着写数据，若文件不存在，则返回打开失败的信息
 ios::out l ios::noreplace  //打开一个新文件作为输出文件，如果文件已存在则返回打开失败的信息
 ios::in l ios::out I ios::binary  //打开一个二进制文件，可读可写

          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";
  2. 关闭文件

    1. 在对已打开的磁盘文件的读写操作完成后，应关闭该文件。关闭文件用成员函数close。如

       outfile.close( );  //将输出文件流所关联的磁盘文件关闭

    2. 所谓关闭，实际上是解除该磁盘文件与文件流的关联，原来设置的工作方式也失效，这样，就不能再通过文件流对该文件进行输入或输出。此时可以将文件流与其他磁盘文件建立关联，通过文件流对新的文件进行输入或输出。如

       outfile.open("f2.dat",ios::app|ios::nocreate);
      1. 此时文件流outfile与f2.dat建立关联，并指定了f2.dat的工作方式。
  3. C++对ASCII文件的读写操作(略。。。。。)
  4. C++对二进制文件的读写操作
    1. 二进制文件不是以ASCII代码存放数据的，它将内存中数据存储形式不加转换地传送到磁盘文件，因此它又称为内存数据的映像文件。因为文件中的信息不是字符数据，而是字节中的二进制形式的信息，因此它又称为字节文件。
    2. 对二进制文件的操作也需要先打开文件，用完后要关闭文件。在打开时要用ios::binary指定为以二进制形式传送和存储。二进制文件除了可以作为输入文件或输出文件外,还可以是既能输入又能输出的文件。这是和ASCII文件不同的地方。
    3. 用成员函数read和write读写二进制文件

      1. 对二进制文件的读写主要用istream类的成员函数read和write来实现。这两个成员函数的原型为

         istream& read(char *buffer,int len);
 ostream& write(const char * buffer,int len);

      2. 字符指针buffer指向内存中一段存储空间。len是读写的字节数。调用的方式为：

         a. write(p1,50);
 b. read(p2,30);
        1. 上面第一行中的a是输出文件流对象，write函数将字符指针p1所给出的地址开始的50个字节的内容不加转换地写到磁盘文件中。在第二行中，b是输入文 件流对象，read 函数从b所关联的磁盘文件中，读入30个字节(或遇EOF结束），存放在字符指针p2所指的一段空间内。

      3. 代码示例：

         //二进制
 int main()
 {
 	char fileName[255] = "c:/teacher.dat";
 	ofstream fout(fileName,ios::binary);
 	if(!fout)
 	{
 		cout << "Unable to open " << fileName << " for writing.\n";
 		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.\n";
 		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;
 }

All content is licensed under CC BY-NC-SA

Buit with Jekyll and 3-Jekyll theme • Hosted on Github

Table of Contents