1. 前言
程序中的数据总是在流动着，既然是流动就会有方向。数据从程序的外部流到程序内部，称为输入；数据从程序内部流到外部称为输出。
C++提供有相应的API实现程序和外部数据之间的交互，统称这类API为 IO 流API。
流是一个形象概念，数据从一端传递到另一端时，类似于水一样在流动，只是流动的不是水，而是数据。
概括而言，流对象可连接 2 端，并在两者之间搭建起一个通道 ，让数据通过此通道流过来、流过去。
2. 标准输入输出流
初学C++时，会接触 cout和cin 两个流对象。
2.1 简介
cout称为标准输出流对象，其一端连接程序，一端连接标准输出设备（标准输出设备一般指显示器），cout的作用是把程序中的数据显示在显示器上。
除了cout，还有cerr，其作用和 cout相似。两者区别：
cout带有数据缓存功能，cerr不带缓存功能。
缓存类似于蓄水池，输出时，先缓存数据，然后再从缓存中输出到显示器上。
cout输出程序通用数据（测试，逻辑结果……），cerr输出错误信息。
另还有一个
clog对象，和cerr类似，与cerr不同之处，带有缓存功能。
cin 称为标准输入流对象，一端连接程序，一端连接标准输入设备（标准输入设备一般指键盘），cin用来把标准输入设备上的数据输入到程序中。
使用 cout和cin时需要包含 iostream头文件。
#include <iostream>
打开 iostream 源代码，可以看到 iostream文件中包含了另外 2 个头文件：
#include <ostream>
#include <istream>
且在 iostream头文件中可以查找到如下代码：
extern istream cin; /// Linked to standard input
extern ostream cout; /// Linked to standard output
extern ostream cerr; /// Linked to standard error (unbuffered)
extern ostream clog; /// Linked to standard error (buffered)
cout、cerr、clog是 ostream类的实例化对象，cin是 istream 类的实例化对象。
2.2 使用
ostream类重载了<< 运算符，istream类重载了>>运算符，可以使用这 2 个运算符方便、快速地完成输入、输出各种类型数据。打开源代码，可以查看到 <<运算符返回调用者本身。意味着使用 cout<<数据时，返回 cout本身，可以以链式方式进行数据输出。
#include <iostream>
using namespace std;
int main(int argc, char** argv) {
string name="果壳";
int age=12;
//链式输出格式
cout<<"姓名:"<<name<<"年龄："<<age;
return 0;
}
istream类重载了 >>运算符，返回调用者（即 istream 对象）本身，也可以使用链式方式进行输入。
#include <iostream>
using namespace std;
int main(int argc, char** argv) {
char sex;
int age;
//链式输入
cin>>sex>>age;
return 0;
}
cout、cin 流对象的其它函数暂不介绍，继续本文的重点文件流。
3. 文件流
文件流 API完成程序中的数据和文件中的数据的输入与输出，使用时，需要包含 fstream头文件。
#include <fstream>
3.1 文件输入流
ifstream从 istream类派生，用来实现把文件中的数据l输入（读）到程序中。
输入操作对程序而言，也称为
读操作。
文件输入流对象的使用流程：
3.1.1 建立流通道
使用 ifstream流对象的 open函数建立起程序和外部存储设备中的文件资源之间的流通道。
文件类型分文本文件和二进制文件。
使用之前，了解一下 open函数的原型说明。打开ifstream头文件，可查看到 ifstream 类中有如下的信息说明：
template<typename _CharT, typename _Traits>
class basic_ifstream : public basic_istream<_CharT, _Traits>
{
/**
* @brief Opens an external file.
* @param __s The name of the file.
* @param __mode The open mode flags.
*
* Calls @c std::basic_filebuf::open(s,__mode|in). If that function
* fails, @c failbit is set in the stream's error state.
*
* Tip: When using std::string to hold the filename, you must use
* .c_str() before passing it to this constructor.
*/
void open(const char* __s, ios_base::openmode __mode = ios_base::in)
{
if (!_M_filebuf.open(__s, __mode | ios_base::in))
this->setstate(ios_base::failbit);
else
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 409. Closing an fstream should clear error state
this->clear();
}
#if __cplusplus >= 201103L
/**
* @brief Opens an external file.
* @param __s The name of the file.
* @param __mode The open mode flags.
*
* Calls @c std::basic_filebuf::open(__s,__mode|in). If that function
* fails, @c failbit is set in the stream's error state.
*/
void open(const std::string& __s, ios_base::openmode __mode = ios_base::in)
{
if (!_M_filebuf.open(__s, __mode | ios_base::in))
this->setstate(ios_base::failbit);
else
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 409. Closing an fstream should clear error state
this->clear();
}
#endif
}
ifstream重载了 open函数，2 个函数参数数量一致，但第一个参数的类型不相同。调用时需要传递 2 个参数：
第一个参数，指定文件的路径。第一个open函数通过 const char* __s类型（字符串指针）接受，第二个open函数通过const std::string& __s类型（字符串对象）接受。
第二个参数，指定文件的打开方式。打开方式是一个枚举类型，默认是 ios_base::in(输入)模式。打开模式如下所示：
enum _Ios_Openmode
{
_S_app = 1L << 0,
_S_ate = 1L << 1,
_S_bin = 1L << 2,
_S_in = 1L << 3,
_S_out = 1L << 4,
_S_trunc = 1L << 5,
_S_ios_openmode_end = 1L << 16
};
typedef _Ios_Openmode openmode;
/// 以写的方式打开文件，写入的数据追加到文件末尾
static const openmode app = _S_app;
/// 打开一个已有的文件，文件指针指向文件末尾
static const openmode ate = _S_ate;
/// 以二进制方式打开一个文件，如不指定，默认为文本文件方式
static const openmode binary = _S_bin;
/// 以输入（读）方式打开文件
static const openmode in = _S_in;
/// 以输出（写）方式打开文件，如果没有此文件，则创建，如有此文件，此清除原文件中数据
static const openmode out = _S_out;
/// 打开文件的时候丢弃现有文件里边的内容
static const openmode trunc = _S_trunc;
打开文件实现：
#include <iostream>
#include <fstream>
using namespace std;
int main(int argc, char** argv) {
ifstream inFile;
//文件路径保存在字符数组中
char fileName[50]="d:\\guoke.txt";
inFile.open(fileName,ios_base::in);
//文件路径保存在字符串对象中
string fileName_="d:\\guoke.txt" ;
inFile.open(fileName_,ios_base::in);
return 0;
}
除了直接调用 open函数外，还可以使用 ifstream的构造函数，如下代码，本质还是调用 open函数。
char fileName[50]="d:\\guoke.txt";
//构造函数
ifstream inFile(fileName,ios_base::in);
或者：
string fileName_="d:\\guoke.txt" ;
ifstream inFile(fileName_,ios_base::in);
可以使用ifstream的 is_open函数检查文件是否打开成功。
3.1.2 读数据
打开文件后，意味着输入流通道建立起来，默认情况下，文件指针指向文件的首位置，等待读取操作。
读或写都是通过移动文件指针实现的。
读取数据的方式：
使用 >> 运算符。
ifstream是istream的派生类，继承了父类中的所有公共函数，如同 cin一样可以使用 >>运算符实现对文件的读取操作。
cin使用>>把标准输入设备上的数据输入至程序。
ifstream使用>>把文件中的数据输入至程序。两者的数据源不一样，目的地一样。
提前在 guoke.txt文件中写入如下内容，也可以用空白隔开数字。
#include <iostream>
#include <fstream>
using namespace std;
int main(int argc, char** argv) {
//用来存储文件中的数据
int nums[10];
//文件输入流对象
ifstream inFile;
//文件路径
char fileName[50]="d:\\guoke.txt";
//打开文件
inFile.open(fileName,ios_base::in);
if(inFile.is_open()) {
//检查文件是否正确打开
cout<<"文件打开成功"<<endl;
//读取文件中的内容
for(int i=0; i<5; i++){
//读取
inFile>>nums[i];
//输出到显示器
cout<<nums[i]<<endl;
}
}
return 0;
}
如上代码，把文件中的 5 个数字读取到 nums 数组中。
用
>>运算符读取时，以换行符、空白等符号作为结束符。
使用get、getline函数。
ifstream类提供有 get、getline函数，可用来读取文件中数据。get函数有多个重载，本文使用如下的 2 个。getline函数和get函数功能相似，其差异之处后文再述。
//以字符为单位读取
istream &get( char &ch );
//以字符串为单位读取
istream &get( char *buffer, streamsize num );
先在 D盘使用记事本创建 guoke.txt文件，并在文件中输入以下 2 行信息：
this is a test
hello wellcome
编写如下代码，使用 get函数以字符类型逐个读取文件中的内容。
#include <iostream>
#include <fstream>
using namespace std;
int main(int argc, char** argv) {
//用来存储文件中的数据
int nums[10];
ifstream inFile;
char fileName[50]="d:\\guoke.txt";
inFile.open(fileName,ios_base::in);
char myChar;
if(inFile.is_open()) {
cout<<"文件打开成功"<<endl;
//以字符为单位读取数据
while(inFile.get(myChar)){
cout<<myChar;
}
}
return 0;
}
//输出结果
this is a test
hello wellcome
读取时，需要知道是否已经达到了文件的未尾，或者说如何知道文件中已经没有数据。
如上使用 get 函数读取时，如果没有数据了，会返回false。
使用 eof函数。eof的全称是 end of file， 当文件指针移动到文件无数据处时，eof函数返回 true。建议使用此函数。
while(!inFile.eof()){
inFile.get(myChar);
cout<<myChar;
}
使用 get的重载函数以字符串类型读取。
#include <iostream>
#include <fstream>
using namespace std;
int main(int argc, char** argv) {
//用来存储文件中的数据
int nums[10];
ifstream inFile;
char fileName[50]="d:\\guoke.txt";
inFile.open(fileName,ios_base::in);
char myChar[100];
if(inFile.is_open()) {
cout<<"文件打开成功"<<endl;
while(!inFile.eof() ) {
//以字符串为单位读取
inFile.get(myChar,100);
cout<<myChar<<endl;
//为什么要调用无参的 get 函数？
inFile.get();
}
}
return 0;
}
输出结果：
上述 get函数以字符串为单位进行数据读取，会把读出来的数据保存在第一个参数 myChar数组中，第二个参数限制每次最多读 num-1个字符。
如果把上述的
inFile.get(myChar,100);
改成
inFile.get(myChar,10);
则程序运行结果如下：
第一次读了 9 个字符后结束 ，第二次遇到到换行符后结束，第三行读了 9 个字符后结束，第四行遇到文件结束后结束 。
为什么在代码要调用无参 get函数？
因为get读数据时会把换行符保留在缓存器中，在读到第二行之前，需要调用无参的 get函数提前清除（读出）缓存器。否则后续数据读不出来。
getline和 get函数一样，可以以字符串为单位读数据，但不会缓存换行符（结束符）。如下同样可以读取到文件中的所有内容。
while(inFile.eof()){
inFile.getline(myChar,100)
cout<<myChar<<endl;
}
使用 read 函数。
除了get和getline函数还可以使用 read函数。函数原型如下：
istream &read( char *buffer, streamsize num );
#include <iostream>
#include <fstream>
using namespace std;
int main(int argc, char** argv) {
//用来存储文件中的数据
int nums[10];
ifstream inFile;
char fileName[50]="d:\\myinfo.txt";
inFile.open(fileName,ios_base::in);
char myChar[100];
if(inFile.is_open()) {
cout<<"文件打开成功"<<endl;
inFile.read(myChar,100);
cout<<myChar;
}
return 0;
}
read一次性读取到num个字节或者遇到 eof（文件结束符）停止读操作。这点和 get和getline不同，后者以换行符为结束符号。
3.1.3 关闭文件
读操作结束后，需要关闭文件对象。
inFile.close();
3.2 文件输出流
ofstream称为文件输出流，其派生于ostream，用于把程序中的数据输出（写）到文件中。和使用 ifstream的流程一样，分 3 步走：
打开文件。
使用 ofstream流对象的 open函数（和 ifstream的 open函数参数说明一样）打开文件，因为是写操作，打开的模式默认是ios_stream::out，当然，可以指定其它的如ios_stream::app模式。
#include <iostream>
#include <fstream>
using namespace std;
int main(int argc, char** argv) {
//输出流对象
ofstream outFile;
char fileName[50]="d:\\guoke.txt";
outFile.open(fileName,ios_base::out);
if (outFile.is_open()){
cout<<"打开文件成功"<<endl;
}
return 0;
}
写操作和读操作一样，有如下几种方案：
- 使用
<<运算符。#include <iostream>
#include <fstream>
using namespace std;
int main(int argc, char** argv) {
//输出流对象
ofstream outFile;
char fileName[50]="d:\\guoke.txt";
outFile.open(fileName,ios_base::out);
if (outFile.is_open()){
cout<<"打开文件成功"<<endl;
for(int i=0;i<10;i++){
//向文件中写入 10 个数字
outFile<<i;
}
}
return 0;
}
输出结果：
- 使用
put 、write函数。put函数以字符为单位向文件中写入数据，put函数原型如下：
ostream &put( char ch );
#include <iostream>
#include <fstream>
using namespace std;
int main(int argc, char** argv) {
//输出流对象
ofstream outFile;
char fileName[50]="d:\\guoke.txt";
outFile.open(fileName,ios_base::out);
if (outFile.is_open()){
cout<<"打开文件成功"<<endl;
for(int i=0;i<10;i++){
//写入 10 个大写字母
outFile.put(char(i+65) );
}
}
return 0;
}
write可以把字符串写入文件中，如下为write函数原型：
ostream &write( const char *buffer, streamsize num );
参数说明：
第一个参数：char类型指针。
第二个参数：限制每次写入的数据大小。
#include <iostream>
#include <fstream>
using namespace std;
int main(int argc, char** argv) {
//输出流对象
ofstream outFile;
char fileName[50]="d:\\guoke.txt";
outFile.open(fileName,ios_base::out);
char infos[50]="thisisatest";
if (outFile.is_open()){
cout<<"打开文件成功"<<endl;
outFile.write(infos,50);
}
return 0;
}
文件中内容：
thisisatest
如果把
outFile.write(infos,50);
改成
outFile.write(infos,5);
则文件中内容为
thisi
关闭资源。
操作完成后，需要调用close函数关闭文件。
outFile.close();
4. 随机访问文件
随机访问指可以根据需要移动二进制文件中的文件指针，随机读或写二进制文件中的内容。
随机访问要求打开文件时，指定文件打开模式为
ios_base::binary。
随机读写分 2 步：
移动文件指针到读写位置。
然后读或写。
随机访问的关键是使用文件指针的定位函数进行位置定位：
gcount() 返回最后一次输入所读入的字节数
tellg() 返回输入文件指针的当前位置
seekg(文件中的位置) 将输入文件中指针移到指定的位置
seekg(位移量，参照位置) 以参照位置为基础移动若干字节
tellp() 返回输出文件指针当前的位置
seekp(文件中的位置) 将输出文件中指针移到指定的位置
seekp(位移量，参照位置) 以参照位置为基础移动若干字节
如下代码，使用文件输出流向文件中写入数据，然后随机定位文件指针位置，再进行读操作。
#include<fstream>
#include<iostream>
using namespace std;
int main() {
int i,x;
// 以写的模式打开文件
ofstream outfile("d:\\guoke.txt",ios_base::out | ios_base::binary);
if(!outfile.is_open()) {
cout << "open error!";
exit(1);
}
for(i=1; i<100; i+=2)
//向文件中写入数据
outfile.write((char*)&i,sizeof(int));
outfile.close();
//输入流
ifstream infile("d:\\guoke.txt",ios_base::in|ios_base::binary);
if(!infile.is_open()) {
cout <<"open error!\n";
exit(1);
}
//定位
infile.seekg(30*sizeof(int));
for(i=0; i<4 &&!infile.eof(); i++) {
//读数据
infile.read((char*)&x,sizeof(int));
cout<<x<<'\t';
}
cout <<endl;
infile.close();
return 0;
}
原文件中内容：
代码执行后的运行结果，并没有输入文件中的所有内容。
5. 总结
本文讲述了标准输入、输出流和文件流对象。
