9 C++输入和输出流
9.1 I/O流的概念和流类库的结构
程序的输入指的是从输入文件将数据传送给程序，程序的输出指的是从程序将数据传送给输出文件。
C++输入输出包含以下三个方面的内容：
对系统指定的标准设备的输入和输出。即从键盘输入数据，输出到显示器屏幕。这种输入输出称为标准的输入输出，简称标准I/O。
以外存磁盘文件为对象进行输入和输出，即从磁盘文件输入数据，数据输出到磁盘文件。以外存文件为对象的输入输出称为文件的输入输出，简称文件I/O。
对内存中指定的空间进行输入和输出。通常指定一个字符数组作为存储空间(实际上可以利用该空间存储任何信息)。这种输入和输出称为字符串输入输出，简称串I/O。
C++的I/O对C的发展--类型安全和可扩展性
在C语言中，用printf和scanf进行输入输出，往往不能保证所输入输出的数据是可靠的安全的。在C++的输入输出中，编译系统对数据类型进行严格的检查，凡是类型不正确的数据都不可能通过编译。因此C++的I/O操作是类型安全(type safe)的。C++的I/O操作是可扩展的，不仅可以用来输入输出标准类型的数据，也可以用于用户自定义类型的数据。
C++通过I/O类库来实现丰富的I/O功能。这样使C++的输人输出明显地优于C 语言中的printf和scanf，但是也为之付出了代价，C++的I/O系统变得比较复杂，要掌握许多细节。
C++编译系统提供了用于输入输出的iostream类库。iostream这个单词是由3个部分组成的，即i-o-stream，意为输入输出流。在iostream类库中包含许多用于输入输出的类。常用的见表
ios是抽象基类，由它派生出istream类和ostream类，两个类名中第1个字母i和o分别代表输入(input)和输出(output)。 istream类支持输入操作，ostream类支持输出操作， iostream类支持输入输出操作。iostream类是从istream类和ostream类通过多重继承而派生的类。其继承层次见上图表示。
C++对文件的输入输出需要用ifstrcam和ofstream类，两个类名中第1个字母i和o分别代表输入和输出，第2个字母f代表文件 (file)。ifstream支持对文件的输入操作， ofstream支持对文件的输出操作。类ifstream继承了类istream，类ofstream继承了类ostream，类fstream继承了类iostream。见图
I/O类库中还有其他一些类，但是对于一般用户来说，以上这些已能满足需要了。
与iostream类库有关的头文件
iostream类库中不同的类的声明被放在不同的头文件中，用户在自己的程序中用#include命令包含了有关的头文件就相当于在本程序中声明了所需 要用到的类。可以换 —种说法：头文件是程序与类库的接口，iostream类库的接口分别由不同的头文件来实现。常用的有
- iostream 包含了对输入输出流进行操作所需的基本信息。
- fstream 用于用户管理的文件的I/O操作。
- strstream 用于字符串流I/O。
- stdiostream 用于混合使用C和C + +的I/O机制时，例如想将C程序转变为C++程序。
- iomanip 在使用格式化I/O时应包含此头文件。
在iostream头文件中定义的流对象
在 iostream 头文件中定义的类有 ios，istream，ostream，iostream，istream _withassign， ostream_withassign，iostream_withassign 等。
在iostream头文件中不仅定义了有关的类，还定义了4种流对象，
| 对象 |
含义 |
对应设备 |
对应的类 |
c语言中相应的标准文件 |
| cin |
标准输入流 |
键盘 |
istream_withassign |
stdin |
| cout |
标准输出流 |
屏幕 |
ostream_withassign |
stdout |
| cerr |
标准错误流 |
屏幕 |
ostream_withassign |
stderr |
| clog |
标准错误流 |
屏幕 |
ostream_withassign |
stderr |
在iostream头文件中定义以上4个流对象用以下的形式（以cout为例）：
ostream cout ( stdout);
在定义cout为ostream流类对象时，把标准输出设备stdout作为参数，这样它就与标准输出设备(显示器)联系起来，如果有
cout <<3;
就会在显示器的屏幕上输出3。
在iostream头文件中重载运算符
“<<”和“>>”本来在C++中是被定义为左位移运算符和右位移运算符的，由于在iostream头文件中对它们进行了重载，使它们能用作标准类型数据的输入和输出运算符。所以，在用它们的程序中必须用#include命令把iostream包含到程序中。
#include
- >>a表示将数据放入a对象中。
- <
标准I/O对象:cin，cout，cerr，clog
cout流对象
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)用“ccmt<<”输出基本类型的数据时，可以不必考虑数据是什么类型，系统会判断数据的类型，并根据其类型选择调用与之匹配的运算符重载函数。这个过程都是自动的，用户不必干预。如果在C语言中用prinf函数输出不同类型的数据，必须分别指定相应的输出格式符，十分麻烦，而且容易出错。C++的I/O机制对用户来说，显然是方便而安全的。3) cout流在内存中对应开辟了一个缓冲区，用来存放流中的数据，当向cout流插人一个endl时，不论缓冲区是否已满，都立即输出流中所有数据，然后插入一个换行符，并刷新流（清空缓冲区）。注意如果插人一个换行符”\n“（如cout<
cerr流对象
cerr流对象是标准错误流，cerr流已被指定为与显示器关联。cerr的作用是向标准错误设备(standard error device)输出有关出错信息。cerr与标准输出流cout的作用和用法差不多。但有一点不同：cout流通常是传送到显示器输出，但也可以被重定向输出到磁盘文件，而cerr流中的信息只能在显示器输出。当调试程序时，往往不希望程序运行时的出错信息被送到其他文件，而要求在显示器上及时输出，这时应该用cerr。cerr流中的信息是用户根据需要指定的。
clog流对象
clog流对象也是标准错误流，它是console log的缩写。它的作用和cerr相同，都是在终端显示器上显示出错信息。区别：cerr是不经过缓冲区，直接向显示器上输出有关信息，而clog中的信息存放在缓冲区中，缓冲区满后或遇endl时向显示器输出。
缓冲区的概念:
9.2.1标准输入流
标准输入流对象cin，重点掌握的函数
cin.get() //一次只能读取一个字符
cin.get(一个参数) //读一个字符
cin.get(三个参数) //可以读字符串
cin.getline()
cin.ignore()
cin.peek()
cin.putback()
标准输入流常见api编程案例
#includeusing namespace std; #include "string" /* 标准输入流对象cin cin.get() //一次只能读取一个字符 cin.get(一个参数) //读一个字符 cin.get(三个参数) //可以读字符串 cin.getline() cin.ignore() cin.peek() cin.putback() */ void main01() { char mybuf[1024]; int myInt; long myLong; cin >> myInt; cin >> myLong; cin >> mybuf; // 遇见空格停止接受 数据 cout << "myInt:" << myInt << "myLong" << myLong << "mybuf:" << mybuf << endl; system("pause"); } //get() void main02() { char ch; //空格也会接收 while ((ch=cin.get())!= EOF) { cout << ch << endl; } system("pause"); } void main03() { char a, b, c; cout << "cin.get(a) 如果缓冲区没有数据,则程序阻塞 \n"; cin.get(a); cin.get(b); cin.get(c); cout << a << b << c << "因为缓冲区有数据,程序不会阻塞\n"; //_Myt& __CLR_OR_THIS_CALL get(_Elem& _Ch) //返回值有引用 cin.get(a).get(b).get(c); cout << a << b << c; system("pause"); } //getline //缓冲区实验 /* 1 输入 "aa bb cc dd" 字符串入缓冲区 2 通过 cin >> buf1; 提走了 aa 3 不需要输入可以再通过cin.getline() 把剩余的缓冲区数据提走 */ void main04() { char buf1[256]; char buf2[256]; cout << "请输入一个字符串 含有多个空格 aa bb cc dd\n"; cin >> buf1; //_Myt& __CLR_OR_THIS_CALL getline(_Elem *_Str, streamsize _Count) cin.getline(buf2, 256); cout << "buf1:" << buf1 << "buf2:" << buf2 << endl; system("pause"); } //案例:输入的整数和字符串分开处理 void main() { 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); //cin.getline(str); getline(cin, str); // //字符串 中间可能有空格 使用 cin.getline(); cout << "You entered a word: " << str << '\n'; //Please, enter a number or a word : adad // You entered a word : adad } system("pause"); } //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;
}
9.2.2标准输出流
#include
using namespace std;
#include
/*
标准输出流对象cout
cout.flush()
cout.put()
cout.write()
cout.width()
cout.fill()
cout.setf(标记)
*/
/*
manipulator(操作符、控制符)
flush
endl
oct
dec
hex
setbase
setw
setfill
setprecision
…
*/
void main01()
{
cout << "hello" << endl;
cout.put('h').put('e').put('l');
char *p = "hello itcast";
cout.write(p, strlen(p)) << endl;
cout.write(p, strlen(p) - 4) << endl;
cout.write(p, strlen(p) + 4) << endl;
system("pause");
return;
}
void main02()
{
//使用类成员函数
cout << "";
cout.width(30);//输出的宽度
cout.fill('*');//填充
cout.setf(ios::showbase); //#include
//cout.setf(ios::internal); //设置 中间隔离
cout << hex << 123 << "\n";//hex把输出的转成16进制
cout << endl << endl;
///
//使用控制符
cout << ""
<< setw(30)
<< setfill('*')
<< setiosflags(ios::showbase) //基数
<< setiosflags(ios::internal)//分割
<< hex
<< 123
<< "\n"
<< endl;
system("pause");
}
int main03()
{
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;
}
int main()
{
double a = 123.456, b = 3.14159, c = -3214.67;
cout << setiosflags(ios::fixed) << setiosflags(ios::right) << setprecision(2);
cout << setw(10) << a << endl;
cout << setw(10) << b << endl;
cout << setw(10) << c << endl;
system("pause");
return 0;
}
/*
标准输出流对象cout
cout.flush()
cout.put()
cout.write()
cout.width()
cout.fill()
cout.setf(标记)
*/
/*
manipulator(操作符、控制符)
flush
endl
oct
dec
hex
setbase
setw
setfill
setprecision
…
*/
标准输出流常见api编程案例
| #include "iostream" using namespace std; #include
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 << " cout.width(30); cout.fill('*'); cout.setf(ios::showbase); //#include cout.setf(ios::internal); //设置 cout << hex << 123 << "
cout << endl; cout << endl; //manipulator(操作符、控制符)
//使用控制阀 cout << " << setw(30) << setfill('*') << setiosflags(ios::showbase) //基数 << setiosflags(ios::internal) << hex << 123 << " << endl;
system("pause"); } |
9.3文件I/O
- 文件输入流ifstream
- 文件输出流ofstream
- 文件输入输出流fstream
- 文件的打开方式
- 文件流的状态
- 文件流的定位：文件指针（输入指针、输出指针）
- 文本文件和二进制文件
9.3.1文件流类和文件流对象
输入输出是以系统指定的标准设备（输入设备为键盘，输出设备为显示器）为对象的。在实际应用中，常以磁盘文件作为对象。即从磁盘文件读取数据，将数据输出到磁盘文件。
和文件有关系的输入输出类主要在fstream.h这个头文件中被定义，在这个头文件中主要被定义了三个类，由这三个类控制对文件的各种输入输出操作，他们分别是ifstream、ofstream、fstream，其中fstream类是由iostream类派生而来，他们之间的继承关系见下图所示。
由于文件设备并不像显示器屏幕与键盘那样是标准默认设备，所以它在fstream.h头文件中是没有像cout那样预先定义的全局对象，所以我们必须自己定义一个该类的对象。
ifstream类，它是从istream类派生的，用来支持从磁盘文件的输入。
ofstream类，它是从ostream类派生的，用来支持向磁盘文件的输出。
fstream类，它是从iostream类派生的，用来支持对磁盘文件的输入输出。
9.3.2C++文件的打开与关闭
打开文件
所谓打开(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:\new\\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的工作方式。
9.3.3C++对ASCII文件的读写操作
如果文件的每一个字节中均以ASCII代码形式存放数据,即一个字节存放一个字符,这个文件就是ASCII文件(或称字符文件)。程序可以从ASCII文件中读入若干个字符,也可以向它输出一些字符。
- 用流插入运算符“<<”和流提取运算符“>>”输入输出标准类型的数据。“<<”和“ >>”都巳在iostream中被重载为能用于ostream和istream类对象的标准类型的输入输出。由于ifstream和 ofstream分别是ostream和istream类的派生类；因此它们从ostream和istream类继承了公用的重载函数，所以在对磁盘文件的操作中，可以通过文件流对象和流插入运算符“<<”及流提取运算符“>>”实现对磁盘文件的读写，如同用cin、cout和<<、>>对标准设备进行读写一样。
- 用文件流的put、get、geiline等成员函数进行字符的输入输出，：用C++流成员函数put输出单个字符、C++ get()函数读入一个字符和C++ getline()函数读入一行字符。
案例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
usingnamespace std;
int main()
{
ofstream myfile("c:\\1.txt",ios::out|ios::trunc,0);
myfile<<"传智播客"<
system("pause");
}文件使用完后可以使用close成员函数关闭文件。
ios::app为追加模式，在使用追加模式的时候同时进行文件状态的判断是一个比较好的习惯。
#include
#include
usingnamespace std;
int main()
{
ofstream myfile("c:\\1.txt",ios::app,0);
if(!myfile)//或者写成myfile.fail()
{
cout<<"文件打开失败，目标文件状态可能为只读！";
system("pause");
exit(1);
}
myfile<<"传智播客"<
}在定义ifstream和ofstream类对象的时候，我们也可以不指定文件。以后可以通过成员函数open()显式的把一个文件连接到一个类对象上。
例如：
#include
#include
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<<"传智播客"<
}下面我们来看一下是如何利用ifstream类对象，将文件中的数据读取出来，然后再输出到标准设备中的例子。
#include
#include
#include
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<
myfile.close();
cout<
}上例中，我们利用成员函数get()，逐一的读取文件中的有效字符，再利用put()成员函数，将文件中的数据通过循环逐一输出到标准设备(屏幕) 上， get()成员函数会在文件读到默尾的时候返回假值，所以我们可以利用它的这个特性作为while循环的终止条件，我们同时也在上例中引入了C++风格的字符串类型string，在循环读取的时候逐一保存到content中，要使用string类型，必须包含string.h的头文件。
我们在简单介绍过ofstream类和ifstream类后，我们再来看一下fstream类，fstream类是由iostream派生而来，fstream类对象可以同对文件进行读写操作。
#include
#include
usingnamespace std;
int main()
{
fstream myfile;
myfile.open("c:\\1.txt",ios::out|ios::app,0);
if(!myfile)
{
cout<<"文件写错误,文件属性可能为只读!"<
exit(1);
}
myfile<<"传智播客"<
myfile.open("c:\\1.txt",ios::in,0);
if(!myfile)
{
cout<<"文件读错误,文件可能丢失!"<
exit(1);
}
char ch;
while(myfile.get(ch))
{
cout.put(ch);
}
myfile.close();
system("pause");
}由于fstream类可以对文件同时进行读写操作，所以对它的对象进行初始话的时候一定要显式的指定mode和openprot参数。
9.3.4C++对二进制文件的读写操作
二进制文件不是以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所指的一段空间内。 -
案例1
//二进制
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;
}
#define _CRT_SECURE_NO_WARNINGS #includeusing namespace std; #include "fstream" void main01() { char* fname = "c:/2aaaaaaafffaaaafff.txt"; ofstream fout(fname, ios::app); //建一个 输出流对象 和文件关联; if (!fout) { cout << "打开文件失败" << endl; return; } fout << "hello....111" << endl; fout << "hello....222" << endl; fout << "hello....333" << endl; //在对已打开的磁盘文件的读写操作完成后，应关闭该文件。关闭文件用成员函数close fout.close(); //读文件 ifstream fin(fname); //建立一个输入流对象 和文件关联 char ch; while (fin.get(ch)) { cout <