目录
9.输入/输出流
数据的输入、输出是最重要的操作，C++ 的输入、输出有 iostream 库提供支持。它利用多继承和虚拟继承实现了面向对象类层次结构。C++ 的输入、输出机制为内置数据类型的输入、输出提供了支持，同时也支持文件的输入、输出。 在此基础上，设计者可以通过扩展 iostream 库，为新类型的数据读写进行扩展。
9.1 C++流类库简介
C 语言中的 scanf 和 printf 很灵巧高效，但不是类型安全的，而且没有扩展性。scanf/printf 系列函数要求把读写的变量和控制读写的格式信息分开。而 C++ 正是克服了这些缺点，使用 cin/cout 控制输入/输出。（类型安全就是指两个类型要相互转换，则必须要显示的转换，而不能隐式的只用一个赋值操作就完成转换）
(1) cin，表示标准输入的 istream 类对象。cin 从终端读入数据。
(2) cout，表示标准输出的 ostream 类对象。cout 向终端写数据。
(3) cerr，表示标准错误输出（非缓冲方式），导出程序错误信息。
(4) clog，表示标准错误输出（缓冲方式），导出程序错误信息。
为了在程序中使用 cin/cout，必须要加 iostream 库的相关头文件 #include <iostream>
iostream 类同时从 istream 类和 ostream 类派生而来，允许双向输入/输出。输入有重载的操作符 >> 完成，输出由重载的操作符 << 来完成。输入输出格式：
cin >> 变量名;
cout << 变量名或常量;除了用户终端的输入/输出，C++ 还提供了文件的输入/输出类：
(1) ifstream，从 istream 派生而来，把文件绑定到程序上输入。
(2) ofstream，从 ostream 派生而来，把文件绑定到程序输出。
(3) fstream，从 iostream 派生而来，把文件绑定到程序输入/输出。
使用 iostream 库的文件流，必须包含相关的头文件：#include <fstream>
文件读写示例：
#include <iostream>
#include <string>
#include <fstream>
using namespace std;
int main()
{
string srsfname("asdfile.txt"); //定义源文件
ifstream srsfile(srsfname.c_str()); //打开源文件流类
if(!srsfile) //失败给出信息
{
cout << "Error:unable to open the infile:" << srsfname <<endl;
return -1;
}
string purfname("purfile.txt"); //定义目标文件
ofstream purfile(purfname.c_str()); //打开目标文件流类
if(!purfile) //失败给出信息
{
cerr << "Error:unable to open the infile:" << purfname <<endl;
return -1;
}
string buf;
while(srsfile >> buf)
{
purfile << buf; //输入到目标文件
}
return 0;
}
9.2 输入/输出流
9.2.1 基本输出流
C++ 的 ostream 提供了丰富的格式化和无格式化的输出功能：用流插入符输出标准数据类型；put 库成员函数输出字符；以八进制、十进制、十六进制输出数据；以各种精确方式输出浮点型数据；以科学计数法定点输出数据；以指定宽度输出数据；在区域内用指定字符填充等。
流输出可以用流插入运算符 —— 即重载的 << 来完成。运算符 << 左边的操作数是 istream 类的一个对象（如cout），右边可以是 C++ 的合法表达式。
用插入运算符实现流输出：
using namespace std;
int main()
{
cout << "hello! C++\n";
cout << "hello! C++" <<endl;
return 0;
}输出操作符可以接受任何内置数据类型的实参，包括 const char*，以及标准库 string 和 complex 类类型。任何表达式包括函数调用，都可以是输出操作符的实参，只要它的计算结果是一个被输出操作符实例接受的数据类型即可。
函数调用作操作符的实参：
using namespace std;
int main()
{
cout << "hello! C++";
cout << strlen("hello! C++") <<endl;
return 0;
}C++ 还提供了指针预定义输出操作符，允许输出项为显式对象的地址。默认情况下，地址以十六进制的形式显式。
#include <iostream>
using namespace std;
int main()
{
int i = 10;
int *p = &i;
cout << "i:" << i << " &i:" << &i <<endl;
cout << "*p" << *p << " p:" << p << " &p:" << &p <<endl;
return 0;
}#include <iostream>
using namespace std;
int main()
{
int i = 10, j = 20;
cout << "The max is ";
cout << (i>j)?i:j;
cout <<endl;
return 0;
}说明：问题在于输入操作符的优先级高于条件操作符，所以输出 i、j 的比较结果的 bool 值。即表达式被解析为：( cout << ( i > j ) ) ? i : j; 。因为 i < j，所以结果为 false，输出结果 0。为了得到正确结果，整个表达式必须放在括号中：cout << ( ( i > j ) ? i : j );。由此得到正确结果：the max is 20。
9.2.2 基本输入流
对应于输出，C++ 提供了实用的输入功能。类似于输出流中的流插入符，输入中引入了流读取符，也称提取符。
流输入可以用流读取运算符 —— 即重载的 >> 来完成。类似于输出运算符 <<，读取符是个双目运算符，左边的操作数是 istream 类的一个对象（如 cin），右边的操作数是系统定义的任何数据类型的变量，例如：int i; cin >> i;从键盘输入的数据会自动转换成 i 的类型，存储到变量 i 中。
注意：(1) 输入运算符 >> 也支持级联输入。在默认情况下，运算符 >> 跳过空格，读入后面与变量类型相应的值。因此给一组变量输入值时，用空格或换行将输入的数值间隔开，例如：
int i;
float f;
cin >> i >> f;(2) 当输入字符串（char* 类型）时，输入运算符 >> 会跳过空格，读入后面的非空格符，直到遇到另外一个空格结束，并在字符串末尾自动放置字符 '\0' 作为结束标志，例如：
char s[20];
cin>> s;(3) 数据输入时，不仅检查数据间的空格，还做类型检查、自动匹配，例如：
int i;
float f;
cin >> i >> f;
9.2.3 格式化输入/输出
在很多情况下，用户希望自己控制输出格式。C++ 提供了两种格式控制方法：通过使用 ios 类中的格式控制函数；使用称为操纵符的特殊类型函数。
ios 类成员函数控制格式
在 ios 类中，格式控制函数主要是通过对状态字、域宽、填充字及其精度来完成的。输入/输出格式由一个 long int 类型的状态字确定。在 ios 类的 public 部分进行了枚举。
skipws 跳过输入中的空白
left 左对齐格式输出
right 右对齐格式输出
internal 在符号位和数值之间填入字符
dec 十进制显示
oct 八进制显示
hex 十六进制显示
showbase 产生前缀，指示数值的进制基数
shwopoint 总是显示小数
uppercase 在十六进制下显示0X，科学计数法显示E
showpos 在非负数值中显示+
boolalpha 把true和false表示为字符串
scientific 以科学计数法形式显示浮点数
fixed 以小数形式显示浮点数
unitbuf 输出操作后立即刷新所有流
stdio 输出操作后刷新stdout和stderr(1) 设置状态标志
设置状态标志可以使用 long ios::setf(long flags) 函数，使用格式如下：
stream_obj.setf(ios::enum_type);说明：其中，stream_obj 为被影响的流对象，常用的是 cin 和 cout。enum_type 为上述列举的值。例如：cout.setf(ios::dec); 表示以十进制输出。要设置多个标志时，彼此间用运算符 " | " 连接（不能连接相反的格式控制符，如：不能 skipwsl|noskipws）。
例如：cout.setf(ios::dec|ios::scientific);//表示以十进制、科学计数法输出。(2) 清除状态标识
清除状态标识可使用 long ios::unsetf(long flags) 函数。使用格式如下：
stream_obj.unsetf(ios::enum_type);使用方法与 ios::setf() 函数相同。
(3) 取状态标识
取状态标志用 flags() 函数，在 ios 类中重载了两个版本：
long ios::flags();
long ios::flags(long flag);前者用于返回当前状态标志字；后者将状态标志字存储在 flag 内。注意的是与 setf() 函数设置状态标志字不同，flags() 函数是取状态标志字的。
应用实例：
#include <iostream>
using namespace std;
void showflags(long f) //输出标志字函数
{
long i;
for(i = 0x8000; i; i = i>>1) //使用右移位
{
if(i&f) //某位不为0，则输出1，否则为0
cout << "1";
else
cout << "0";
}
cout <<endl;
}
int main()
{
long flag;
flag = cout.flags();
showflags(flag);
cout.setf(ios::dec|ios::boolalpha|ios::skipws);
flag = cout.flags();
showflags(flag);
cout.unsetf(ios::skipws);
flag = cout.flags();
showflags(flag);
return 0;
}函数 showflags() 的功能是输出状态字的二进制数值。算法思想是，从最高位到最低位，逐位计算与二进制 1 的位与（即从 0x8000 开始逐个移位循环 16 次到 0x0001），并输出该二进制位的数值（只有二进制位为 1 时，结果才为 1，否则为 0），由此得到状态字各个二进制位的数值。
第一行显式的是系统默认状态下的状态标志字值，skipws 和 unitbuf 被设定（查相应的标志数值表得到）。第二行显式的默认状态下，并追加了 ios::dec|ios::boolalpha|ios::skipws 的状态标志， skipws 是已有标志，没有变化相应的二进制位，而 ios::dec 和 ios::boolalpha 位发生了变化。第三行显式的是去掉 ios::skipws（执行函数 unsetf() 后得到）后状态字的变化，显式最后一位是控制 ios::skipws 的标志位。
(4) 设置域宽
域宽用于控制输出格式，在 ios 类中重载了两个函数来控制域宽，原型如下：
int ios::width();
int ios::width(int w);第一个函数得到当前的域宽值；第二个函数用来设置新域宽，并返回原来的域宽值。需要注意的是：所设置的域宽仅仅对下一个输出的操作有效，当完成一次输出操作后，域宽值又恢复为 0。
(5) 设置填充字符
填充字符的作用是，当输出值不满足域宽时用设定的字符来填充，默认情况下填充的字符为空格。实际应用中填充字符函数与设置域宽函数 width() 配合使用，否则无空可填，毫无意义。ios 类提供了两个重载的成员函数来操作填充字符，原型如下：
char ios::fill();
char ios::fill(char c);第一个函数返回当前使用的填充字符；第二个函数设置新的填充字符，并返回设置前的填充字符。
(6) 设置显示精度
类似地，ios 类也提供了重载的两个函数来控制显示精度，函数原型如下：
int ios::precision();
int ios::precision(int num);第一个函数返回当前设置精度值；第二个函数设置新的显示精度。
输入/输出实例：
#include <iostream>
using namespace std;
int main()
{
int i = 123;
float f =2018.0903;
const char* const str = "hello! every one!";
cout << "default width is:" << cout.width() <<endl; //默认域宽
cout << "default fill is:" << cout.fill() <<endl; //默认的填充字符
cout << "default precision is:" << cout.precision() <<endl; //默认精度
cout << "i = " << i << " f = " << f << " str = " << str <<endl;
cout << "i = ";
cout.width(12); //设域宽
cout.fill('*'); //设填充字符
cout << i <<endl;
cout << "i(hex) = ";
cout.setf(ios::hex, ios::basefield); //设十六进制
cout << i;
cout << " i(oct) = ";
cout.setf(ios::oct, ios::basefield); //八进制
cout << i <<endl;
cout << "f = ";
cout.width(12);
cout.precision(3); //设精度
cout << f <<endl;
cout <<"f = ";
cout.width(12);
cout.setf(ios::fixed, ios::floatfield);
cout << f <<endl;
cout << "str = ";
cout.width(20);
cout.setf(ios::left); //设左对齐
cout << str <<endl;
return 0;
}
操纵符控制格式
通过上面代码发现，使用 ios 类成员函数控制输入、输出格式，必须靠流对象来调用，而且不能直接嵌入到输入、输出语句中，使用不够简洁方便。C++ 提供了另一中控制格式的方法，称为操纵符方法，类似于函数的运算符。使用操纵符方法可以嵌入到输入、输出语句中，使用简洁方便。
所有不带参数的操作符定义在头文件 iostream.h 中，带形参的操纵符定义在头文件 iomanip.h 中，使用操纵符时需要包含相应的头文件。常用的有：
ws 在输入时跳过开头的空白符，仅用于输入
endl 换行并刷新输出流，仅用于输出
ends 插入一个空字符，仅用于输出
dec 十进制显示
oct 八进制显示
hex 十六进制显示
setfill(ch) 用ch填充空白字符
setprecision(n) 将浮点数精度设置为n
setw(w) 按照w个字符来读或写数值
setbase(b) 以进制基数b来输出整数值
setiosflags(n) 设置由n指定的格式标志
resetiosflags(n) 清除由n指定的格式标志在进行输入、输出时，操纵符被嵌入到输入、输出语句中，用来控制格式。使用操纵符与成员函数的对比：
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
int i = 123;
float f =2018.0903;
const char* const str = "hello! every one!";
cout << "default width is:" << cout.width() <<endl;
cout << "default fill is:" << cout.fill() <<endl;
cout << "default precision is:" << cout.precision() <<endl;
cout << "i = " << i << " f = " << f << " str = " << str <<endl;
cout << "i = " << setw(12) << setfill('*') << i <<endl;
cout << "i(hex) = " << hex << i << " i(oct) = " << oct << i << endl;
cout << "f = " << setw(12) << setprecision(3) << f <<endl;
cout << "f = " << setw(12) << fixed << f <<endl;
cout << "str = " << setw(20) << left << str <<endl;
return 0;
}
用户自定义的操纵符控制格式
在 C++ 中，除了系统提供的预定义操纵符之外，还允许用户自己定义操纵符，便于控制一些频繁使用的格式操作，使得格式控制更加方便。
自定义输出流操纵符算子格式如下：
ostream & 自定义输出操纵符算子函数名 (ostream& stream)
{
...//自定义代码
return stream;
}自定义输入流操纵符算子格式如下：
istream & 自定义输出操纵符算子函数名 (istream& stream)
{
...//自定义代码
return stream;
}自定义输出操作函数：
#include <iostream>
#include <iomanip>
using namespace std;
ostream &myoutput(ostream& stream)
{
stream << setw(10) << setfill('#') <<left;
return stream;
}
int main()
{
int i = 123;
cout << i <<endl;
cout << myoutput << i <<endl;
return 0;
}自定义操纵符函数 myoutput()，功能是设置域宽为 10，填充字符为 #，并采用左对齐。函数参数为引用方式，cout 的返回值为引用方式且可以多级输出，所以在主函数中只写 myoutput 即可。
自定义输入操作函数：
#include <iostream>
using namespace std;
istream &myinput(istream& stream)
{
cout << "please input a hex integer:";
stream >> hex;
return stream;
}
int main()
{
int i;
cin >> myinput >> i;
cout << "i(dec) = " << i << " i(hex) = " << hex << i <<endl;
return 0;
}
9.2.4 其他的输入/输出函数
正如在 C 语言中遇到的问题一样，输入字符串时，仅靠 cin 只能得到不包括空格的字符串。针对此类问题，C++ 还提供了以下输入/输出的函数。
get()、put()函数get(char& ch) 从输入流中提取一个字符，包括空白字符，并把它存储在 ch 中，返回被应用的 istream 对象。此函数在类 istream 里。对应于 get()，类 ostream 提供了 put(char ch) 函数，用于输出字符。
get()的重载版本：get(char *str, streamsize size, char delimiter = '\n');str 代表一个字符数组，用来存放被读取的字符。size 代表可以从 istream 中读入的字符的最大数目。delimiter 表示如果遇到它就结束读取字符的动作，delimiter 本身不会被读入，而是留在 istream 中，作为 istream 的下一个字符。一个常见的错误是，执行第二个 get() 时省略 delimiter。下面例子使用 istream 的成员函数 ignore() 来去掉 delimiter。默认情况下，delimiter 为换行符。
get/put 函数实例（直接换行结束）：
#include <iostream>
using namespace std;
int main()
{
const int str_len = 100;
char str[str_len];
while(cin.get(str,str_len))
//当读入的数据不为空时循环下一次，每次最多读入str_len个
{
int count = cin.gcount(); //当前实际读入多少个字符
cout << "the number is:" << count <<endl;
if(count < str_len)
cin.ignore(); //在下一行之前去掉换行符
}
return 0;
}
getline() 函数
使用 get() 函数输入字符串时，经常忘记去掉 delimiter，所以引入函数 getline()，因为 getline() 会丢弃终结符。其原型与 get() 的重载版本相同：
getline(char *str, streamsize size, char delimiter = '\n');write()、read() 函数
ostream 类成员函数 write() 提供一种输出字符数组的方法。它不是输出 "直到终止字符为止"，而是输出某个长度的字符序列，包括空字符。函数原型如下：
write(char *str, streamsize length);str 是要输出的字符数组，length 是要显示的字符个数。write() 返回当前被调用的 ostream 类对象。
istream 类的 read() 函数，原型如下：
read(char *str, streamsize size);read() 函数从输入流中读取 size 个连续的字符，并将其放在地址从 str 开始的内存中。gcount() 方法返回最后一个非格式化的抽取方法读取的字符数。这意味着字符由 get()、getline()、ignore()、或 read() 方法读取的，不是由抽取操作符（ >> ）读取的，抽取操作符对输入进行格式化，使之与特定的数据类型匹配。
输入/输出综合实例：
#include <iostream>
using namespace std;
int main()
{
const int str_len = 100;
char str[str_len];
int iline = 0; //行数
int max = -1; //最长行的长度
while(iline < 3)
{
cin.getline(str, str_len);
int num = cin.gcount();
cout << "the number is:" << num <<endl;
iline++;
if(num > max)
max = num;
cout << "Line#" << iline << "\t chars read:" << num <<endl;
cout.write(str, num).put('\n').put('\n');
}
cout << "Total lines:" << iline <<endl;
cout << "The longest line:" << max <<endl;
return 0;
}
9.3自定义类型的输入/输出
当实现一个类的类型时，有时希望这个类支持输入和输出操作，以便可以将类对象嵌入到输入或输出流中。前面的函数都是 C++ 系统预定义数据类型的输入/输出。对于用户自己定义的数据类型的输入/输出，可以通过重载运算符 ">>" 和 "<<" 实现。
9.3.1 重载输出运算符 "<<"
其重载函数的格式如下：
ostream & operator << (ostream &out, class_name &obj)
{
out << obj.data1;
out << obj.data2;
......
out << obj.datan;
return out;
}函数中第一个参数 out 时对 ostream 对象的引用，即 out 必须是输出流对象；第二个参数是用户自定义要输出的类对象的引用。data1，data2，... datan 是类内要输出的数据成员。输出运算符 "<<" 不能作为类的成员函数，只能作为友元函数（要访问类的私有成员）来实现。
输出运算符重载：
#include <iostream>
#include <string.h>
using namespace std;
class Word
{
char *word;
size_t num; //存储的字符个数
public:
Word(const char* const str = NULL);
virtual ~Word()
{
if(word) //清除指针
delete []word;
}
friend ostream& operator<<(ostream& out, Word& sword);
};
Word::Word(const char* const str)
{
if(str != NULL)
{
num = strlen(str);
word = new char[num+1];
strcpy(word,str);
}
}
ostream& operator<<(ostream& out, Word& sword)
{
out << "<" << sword.num << ">" << sword.word <<endl;
return out;
}
int main()
{
Word word("hello");
cout << word;
return 0;
}程序为类 word 重载输出运算符 "<<"，使得可以通过 cout 简单地输出 word 类对象的内容：字符串和字符串长度。在类 word 的构造函数里，为类成员 word 申请空间（包括字符串结束标志 '\0'），在析构函数中，相应地释放成员 word 的空间。重载函数的第二个参数为引用形式，可以转为普通形式，但是引用减少了调用开销。
9.3.2 重载输入运算符 ">>"
输入运算符 ">>"，又称为提取运算符，定义其重载函数的格式如下：
istream &operator>>(istream &in, class_name& obj)
{
in >> obj.data1;
in >> obj.data2;
......
in >> obj.datan;
return out;
}函数中第一个参数 in 是对 istream 对象的引用，即 in 必须是输入流对象；第二个参数是用户自定义要输入的类对象的引用。data1，data2 ... datan 是类内要输入的数据成员。输入运算符也不能作为类的成员函数，只能作为类的友元函数或独立函数。重载函数第二个参数必须为引用，且不能为常引用，因为要对参数进行修改。
输入运算符重载：
#include <iostream>
#include <string.h>
using namespace std;
class Word
{
char *word;
size_t num;
public:
Word(const char* const str = NULL);
virtual ~Word()
{
if(word)
delete []word;
}
friend ostream& operator<<(ostream& out, Word& sword);
friend istream& operator>>(istream& in, Word& sword);
};
Word::Word(const char* const str)
{
if(str != NULL)
{
num = strlen(str);
word = new char[num+1];
strcpy(word,str);
}
}
ostream& operator<<(ostream& out, Word& sword)
{
out << "<" << sword.num << ">" << sword.word <<endl;
return out;
}
istream& operator>>(istream& in, Word& sword)
{
char str[100];
in.getline(str, 100);
if(in.gcount() > 0)
{
delete []sword.word;
sword.num = strlen(str);
sword.word = new char[sword.num+1];
strcpy(sword.word, str);
}
return in;
}
int main()
{
Word word("hello");
cout << word;
cin >> word;
cout << word;
return 0;
}
9.4 文件输入/输出
变量中的数据保存在内存中，是临时的；文件数据保存在外存储器上，用于永久的保存大量的数据。根据数据的组织形式，文件分为文本文件和二进制文件。文本文件的每个字节存放一个 ASCII 代码，代表一个字符；二进制文件把内存中的数据，按照其在内存中的存储形式原样写到磁盘上存放。
C++ 把每个文件看成一个有序的字节流（字符流或二进制流）。每个文件不是以文件结束符结束，就是以在系统维护和管理的数据结构中特定的字符结束。文件打开时，就会创建一个对象，将这个对象和某个流关联起来。C++ 中，要进行文件的输入/输出，必须首先创建一个流，与文件关联，才能进行读写操作。
C++ 进行文件处理时，需要包含头文件 <iostream.h> 和 <fstream.h>。<fstream.h> 头文件包括流类 ifstream（从文件输入）、ofstream（向文件输出）和 fstream（从文件输入/输出）的定义。这三个流分别从 istream、ostream 和 iostream 类继承而来。#include<iostream.h> 是非标准输入输出流，#include<iostream> 是标准输入输出流。C++ 中为了避免名字定义冲突，特别引入了 "名字空间的定义"，即 namespace。当代码中用 <iostream.h> 时，输出可直接引用 cout<<x;，<iostream.h> 继承 C 语言的标准库文件，未引入名字空间定义，所以可直接使用。当代码中引入 <iostream> 时，输出需要引用 std::cout<<x; 如果还是按原来的方法就会有错。使用 <iostream> 时，引入 std:: 有以下方法：
① using namespace std;
cout << x;
② using std::cout;
cout << x;
③ 最基本的std::cout << x;其他头文件也是同样的道理。（有 ".h" 的就是非标准的，C 的标准库函数。无 ".h"的，就要用到命令空间，是 C++ 的。还有一部分不完全是有 ".h" 和没 ".h" 的差别。例如：math.h和cmath）。
9.4.1 顺序访问文件
C++ 把文件视作无结构的字节流，所以记录等说法在 C++ 中不存在。要正确地进行文件的输入\输出，需要遵循以下步骤。
(1) 定义相关的流对象
包含头文件 <fstream.h> 建立流，定义流对象。
例如：
ifstream in; //输入文件流
ofstream out; //输出文件流
fstream inout; //输入/输出文件流(2) 文件的打开
打开文件有两种方式。
①：使用 open() 函数
open 函数是 ifstream、ofstream 和 fstream 类的成员函数。原型定义如下：
void open ( const char *,ios_base::openmode mode = ios_base::in | ios_base::out );
void open ( const unsigned char *, int mode, int access = filebuf::openprot );第一个参数用来传递文件名称；第二个参数 mode 决定文件的打开方式第三个。
打开方式：
ios::app 将输出写入文件末尾
ios::ate 打开文件，并将文件指针移到文件末尾
ios::in 打开文件进行输入
ios::out 打开文件进行输出
ios::nocreate 文件不存在，则open()失败
ios::noreplace 文件存在，则open()失败
ios::trunc 删除文件中现有数据(覆盖同名文件)
ios::binary 以二进制方式打开，进行输入/输出(默认方式为文本方式)
打开文件的属性：
0 普通文件，打开操作
1 只读文件
2 隐含文件
4 系统文件例如：
ofstream out;
out.open("test.tt", ios::out); //表示用输出流对象out打开一个"test.tt"文件。当一个文件需要多种方式打开时，可以用”或”操作符把几种方式连接在一起。例如打开一个能用于输入\输出的二进制文件:
fstream inout;
inout.open("test.tt", ios::in | ios::out | ios::binary);打开文件后要判断是否打开成功：
if(inout.is_open()) //如果打开成功则进行读写操作
{...}
②：流类构造函数打开
虽然完全可以用 open() 函数打开文件，但是类 ifstream、ofstream 和 fstream 中的构造函数都有自动打开文件功能，这些构造函数的参数及默认值与 open() 函数完全相同。因此，打开文件的最常见形式简化为：文件输入/输出流类 流对象名("文件名称");
例如：ofstream out("test.tt");使用构造函数打开文件后，直接使用流对象判断是否打开成功。
if(!out)
{
cout << "文件打开失败！" <<endl;
//错误处理
}(3) 文件的读写
文件一旦打开，从文件中读取数据或向文件中写入数据将变得十分容易，只需要使用运算符 ">>" 和 "<<" 就可以了，只是必须用与文件相连接的流对象代替 cin 和 cout。例如：
ofstream out("test.tt");
if(out)
{
out << 10 << "hello!\n";
out.close();
}(4) 文件的关闭
使用完文件后，应该把它关闭，即把打开的文件与流分开。对应于 open() 函数，使用 close() 函数关闭文件。在流对象的析构函数中，也具有自动关闭功能。
① 文本文件读写（文件的打开方式默认为文本方式）
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
char str[20] = "Welcome to C++!";
int i = 1234;
char ch;
ofstream out("test.tt"); //打开输出文件流
if(out) //如果成功
{
out << str << '\n' << i; //向文件输入信息
out.close(); //关闭
}
ifstream in("test.tt"); //打开输入文件流
if(in)
{
while(in.get(ch)) //输出显示
cout << ch;
cout <<endl;
in.close();
}
return 0;
}② 二进制文件读写
文本文件中存放的是字符，而二进制文件中存放的是二进制位。对二进制文件读写有两种方式，一种是使用 get() 和 put() 函数。一种是使用 read() 和 write() 函数。当然，这 4 个函数也可用于文本文件的读写。
get() 函数和 put() 函数原型如下：
istream& get(unsigned char& ch);
ostream& put(char ch);get() 是类 istream 的成员函数，功能是从文件流中只读取一个字节，并把值放在 ch 中，put() 是类 ostream 的成员函数，功能是向文件流中写入一个字节 ch。当读文件过程中遇到结束符时，与之相连的文件流值变为 0，所以可以根据此判断文件是否结束。
二进制文件读写实例：
#include <iostream>
#include <fstream>
using namespace std;
void myread(const char* fname)
{
ifstream file_read(fname, ios::binary);
char c;
if(file_read)
{
while(file_read.get(c)) //文件没有结束时
cout << c;
}
}
void mywrite(const char* fname)
{
ofstream file_write(fname, ios::binary);
char c = 'A';
if(file_write)
{
for(int i = 0; i < 26; i++)
file_write.put(c+i);
}
}
int main()
{
char fname[20] = "word.file";
mywrite(fname);
myread(fname);
cout <<endl;
return 0;
}read() 函数和 write() 函数原型如下：
istream& read(unsigned char* buf, int num);
ostream& write(const unsigned char* buf, int num);有时需要读写一组数据到文件，read() 函数是类 istream 的成员函数，它从相应的流中读取 num 个字节放在 buf 所指向的缓冲区中。write() 函数是 ostream 的成员函数，它从 buf 所指的缓冲区中向相应的流写入 num 个字节。例如：
int list[] = {12, 13, 14, 15};
write((unsigned char*)&list, sizeof(list));定义了一个整形数组 list，为了写入它的全部数据，必须在函数 write() 中指定它的首地址 &list，并转换为 unsigned char* 类型，由 sizeof() 指定要写入的字节数。
一组数据的文件读写实例：
#include <iostream>
#include <fstream>
using namespace std;
void myread(const char* fname)
{
ifstream file_read(fname, ios::binary);
char c[30];
if(file_read)
{
file_read.read(c, 26*sizeof(char));
c[26] = '\0';
cout << c <<endl;
}
}
void mywrite(const char* fname)
{
char c[30];
for(int i = 0; i < 26; i++)
c[i] = 'A' + i;
ofstream file_write(fname, ios::binary);
if(file_write)
file_write.write(c, 26*sizeof(char));
}
int main()
{
char fname[20] = "word.file";
mywrite(fname);
myread(fname);
return 0;
}
9.4.2 随机访问文件
顺序访问文件不适合快速访问的应用程序。为了增加程序的灵活性和快捷性，立即找到特定记录信息，C++ 提供了随机移动文件访问指针的函数，可以移动输入/输出流中的文件指针，从而对文件数据进行随机读写。
获得和设置流指针
所有输入/输出流对象都有至少一个流指针：
ifstream， 类似 istream，有一个被称为 get pointer 的指针，指向下一个将被读取的元素。
ofstream，类似 ostream，有一个指针 put pointer ，指向写入下一个元素的位置。
fstream， 类似 iostream，同时继承了get 和 put。
tellg() 和 tellp()
这两个成员函数不用传入参数，返回 pos_type 类型的值(根据 ANSI-C++ 标准) ，就是一个整数，代表当前 get 流指针的位置 （用 tellg） 或 put 流指针的位置（用 tellp）。
C++ 支持的文件流中，通过文件指针方式从相应的文件位置进行读写。其中的 get() 函数指针用于指出下一次输入操作的位置；put() 函数指针用于指出下一个输出操作的位置。每当发生一次读写操作时，相应的 get() 函数指针或 put() 函数指针会自动连续地增加。另外也可以使用 seekg() 函数和 seekp() 函数迅速定位，找到指定的位置访问文件。函数原型如下：
ostream& seekp(streamoff off, ios::seek_dir dir);
istream& seekg(streamoff off, ios::seek_dir dir);函数 seekp() 用于输出文件，将相应的文件指针 get 从 dir 的位置移动 off 个字节；函数 seekg() 用于输入文件，将相应的文件指针 put 从 dir 的位置移动到 off 个字节。
其中类型 streamoff 相当于 long 类型，定义文件指针要偏移的位置范围。参数 dir 表示文件指针的起始位置，off 表示相对于这个位置移动的位偏移量。dir 取值如下：
ios::beg:从文件头开始，此时off取值为正。
ios::cur:从文件当前位置开始，此时off取值为负。
ios::end:从文件末尾开始，此时off取值可正可负。获得一个二进制文件的大小：
#include <iostream.h>
#include <fstream.h>
const char * filename = "test.txt";
int main()
{
long l,m;
ifstream in(filename, ios::in|ios::binary);
l = in.tellg();
in.seekg (0, ios::end);
m = in.tellg();
in.close();
cout << "size of " << filename;
cout << " is " << (m-l) << " bytes.\n";
return 0;
}
随机访问文件实例：
#include <iostream>
#include <fstream>
using namespace std;
void myread(const char* fname)
{
ifstream file_read(fname, ios::binary);
char c[10];
if(file_read)
{
file_read.seekg(1, ios::beg); //从开始位置移动1位
file_read.get(c[0]); //读取一个字符
file_read.seekg(2, ios::cur); //从当前位置移动2位
file_read.get(&c[1], 4*sizeof(char));
//一次读取1个字符，连续读取3次，最后一个'\0'
cout << c;
}
}
void mywrite(const char* fname)
{
char c[30];
for(int i = 0; i < 26; i++)
c[i] = 'A' + i;
ofstream file_write(fname, ios::binary);
if(file_write)
file_write.write(c, 26*sizeof(char));
}
int main()
{
char fname[20] = "word.file";
mywrite(fname);
myread(fname);
cout <<endl;
return 0;
}
1762
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
