目录
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;
}