|
|
请使用QQ关联注册PLM之家,学习更多关于内容,更多精彩原创视频供你学习!
您需要 登录 才可以下载或查看,没有账号?注册
×
ofstream是从内存到硬盘,ifstream是从硬盘到内存,其实所谓的流缓冲就是内存空间;2 J" ?# E1 g0 N/ i5 ^) d
: U! I; N2 ~, h+ @' e1 y
在C++中,有一个stream这个类,所有的I/O都以这个“流”类为基础的,包括我们要认识的文件I/O,stream这个类有两个重要的运算符:1 W* R% f# W( k. Y
' T2 `2 @- w$ N1 S0 x; |& ]
1、插入器(<<)
+ P/ u' f: }" o) Y8 I; I( j
2 |4 r8 n. r9 @5 C5 M" e) r3 U 向流输出数据。比如说系统有一个默认的标准输出流(cout),一般情况下就是指的显示器,所以,cout<<"Write Stdout"<<'\n';就表示把字符串"Write Stdout"和换行字符('\n')输出到标准输出流。. O5 O, h" ]) w4 d" W
' U! K3 [; ~+ y 2、析取器(>>)
% L3 Z$ ~" r/ q9 |) s4 n; x
: P- v* K" A* c3 t& i8 e0 t 从流中输入数据。比如说系统有一个默认的标准输入流(cin),一般情况下就是指的键盘,所以,cin>>x;就表示从标准输入流中读取一个指定类型(即变量x的类型)的数据。3 O! G% n5 q9 y* ?
! e; V1 @. h* N G0 Q
在C++中,对文件的操作是通过stream的子类fstream(file stream)来实现的,所以,要用这种方式操作文件,就必须加入头文件fstream.h。下面就把此类的文件操作过程一一道来。& `6 |; m5 v+ P8 P: R$ q
7 K3 E' M# f4 l
一、打开文件8 r5 }5 o4 e, q! z6 y! [5 ~
4 ?, m n" @/ j7 Z( _$ q; p& u 在fstream类中,有一个成员函数open(),就是用来打开文件的,其原型是:
$ h3 X! }9 U, a$ b/ e
! k- E' k. Q! Z3 ?8 f; k, K z void open(const char* filename,int mode,int access);参数:2 \& S* N* T" B( l" t, h
; C! R5 J8 [5 ^: P$ a8 K filename: 要打开的文件名
) ^3 `" I# @9 e1 ~) E0 p$ S+ f
" v. O2 k% t0 B0 M A8 O: g mode: 要打开文件的方式& {4 ?$ d% K A/ V" ?
: W" ?, a, t9 B( n3 Q+ l9 s access: 打开文件的属性% b% H& C$ Y, l; b! e
! D. | x2 T. }5 J3 ?# Y
打开文件的方式在类ios(是所有流式I/O类的基类)中定义,常用的值如下:' B" A; v8 p/ D& i2 R Q: y% B- \
/ E/ G2 e Y2 C U4 m ios::app: 以追加的方式打开文件
, R! B: e' w1 Z( A" _ ( E! t6 G4 Z' V/ L& f
ios::ate: 文件打开后定位到文件尾,ios:app就包含有此属性! s. ^' e# R6 C! W+ B8 z7 ~
0 J& V* O( c+ @6 _% X7 f$ U
ios::binary: 以二进制方式打开文件,缺省的方式是文本方式。两种方式的区别见前文
5 e& {9 y% u( _! B 3 [# P* K. @3 T" r Z
ios::in: 文件以输入方式打开(文件数据输入到内存)
# Z6 V6 u) ?* X
2 n- X2 U* W4 \& C7 O4 A5 Y ios::out: 文件以输出方式打开(内存数据输出到文件)
2 K& ^$ K$ f. V r* e
3 \# z8 j8 A5 ^/ T8 ^ ios::nocreate: 不建立文件,所以文件不存在时打开失败! e4 q3 s. L8 o: X! D+ O, ^8 N
+ T- L: v4 @* {) y ios::noreplace:不覆盖文件,所以打开文件时如果文件存在失败
' @4 [* n+ J. n4 r! a, `
- _3 S. ~5 D. s. H# t& ? ios::trunc: 如果文件存在,把文件长度设为04 ~+ p2 Y8 T. l
: P: g7 e5 b' M* m: |; k
可以用“或”把以上属性连接起来,如ios::out|ios::binary
4 o5 C& @8 X+ C% o ^
0 t5 H2 h9 O3 m 打开文件的属性取值是:
) @0 l+ m0 L% X5 v1 [& ? D; A- w3 U0 P( h8 E# ]
0:普通文件,打开访问
5 \4 _! C, O, a
( C; \' j, t5 T9 J K 1:只读文件
' F8 c+ M4 b2 u0 G
6 S0 O$ E' G$ w" Z/ M# H 2:隐含文件- u0 D% L6 x) P, e- g* n- W
" u, `: t3 t4 }% `' K
4:系统文件 J+ q- T( J+ Z; e1 i
5 Y! v" n6 g: b$ q 可以用“或”或者“+”把以上属性连接起来,如3或1|2就是以只读和隐含属性打开文件。% K5 l+ _- f: U# t0 K5 R8 T
$ _8 e. m7 }* i) o0 j0 q! R# W 例如:以二进制输入方式打开文件c:\config.sys; H5 B9 C' O8 X2 [1 X0 T
1 E# H3 j0 j" w" o1 i7 c3 ^
fstream file1;' D9 c2 j6 G1 G0 ~
( @; b k: f) E! I( L6 v0 N
file1.open("c:\\config.sys",ios::binary|ios::in,0);/ ^# G$ E2 s6 I: `( m
o0 H9 i* H l. Z: H7 b 如果open函数只有文件名一个参数,则是以读/写普通文件打开,即:
5 g2 d' c J' d8 q# G8 V + ~- O. `" M# l; k; K0 z, ^* r
file1.open("c:\\config.sys"); <=> file1.open("c:\\config.sys",ios::in|ios::out,0);
1 }* L6 }, ^( ^' P, w6 P
$ z3 l+ {5 ]. ?/ B1 A, B1 [" a 另外,fstream还有和open()一样的构造函数,对于上例,在定义的时侯就可以打开文件了:
+ e! T" y' O6 g: @ * E, K* y) Z# h8 O
fstream file1("c:\\config.sys"); 特别提出的是,fstream有两个子类:ifstream(input file stream)和ofstream(outpu file stream),ifstream默认以输入方式打开文件,而ofstream默认以输出方式打开文件。0 n, a& W! D1 ~/ j2 O
+ w7 T1 B' l0 p4 p
ifstream file2("c:\\pdos.def");//以输入方式打开文件
& l, J& l9 K# l1 b5 l
, Q9 n0 k5 y* q( Y' C: o5 ?: ^ ofstream file3("c:\\x.123");//以输出方式打开文件 所以,在实际应用中,根据需要的不同,选择不同的类来定义:如果想以输入方式打开,就用ifstream来定义;如果想以输出方式打开,就用ofstream来定义;如果想以输入/输出方式来打开,就用fstream来定义。6 E( }* |! ~% E+ }0 |8 Q
: \6 `) c/ ?8 m! a& b2 G
二、关闭文件
6 |8 W {9 r; V! O9 O ' E) F \1 x) H
打开的文件使用完成后一定要关闭,fstream提供了成员函数close()来完成此操作,如:file1.close();就把file1相连的文件关闭。
' F& l) a4 J5 s / N# l$ X8 U. f; ?5 n
三、读写文件; ~/ U1 z8 F, `# e* U' D2 m2 {
6 d. X, \5 V$ y1 L! b4 |) q 读写文件分为文本文件和二进制文件的读取,对于文本文件的读取比较简单,用插入器和析取器就可以了;而对于二进制的读取就要复杂些,下要就详细的介绍这两种方式
& h4 j7 A0 E b1 } $ m1 ^7 J! N( t" C! _* ]
1、文本文件的读写- i9 W% F5 k7 c3 `
* r2 K! t- q) J! [
文本文件的读写很简单:用插入器(<<)向文件输出;用析取器(>>)从文件输入。假设file1是以输入方式打开,file2以输出打开。示例如下:0 }2 D& m2 R. \1 M6 c
- P$ Z& i! C- W) Q
file2<<"I Love You";//向文件写入字符串"I Love You"
# M" Z# |9 Q1 s% S6 V
0 v2 G( p9 }/ b9 X9 k& i int i;
7 \) J4 L. |$ A; q% [$ T Z8 W7 W5 W6 U4 b9 B8 N7 R8 {
file1>>i;//从文件输入一个整数值。3 u3 e9 H+ c, f9 x7 _% N
& `( j% V, l6 K' g4 m8 v
这种方式还有一种简单的格式化能力,比如可以指定输出为16进制等等,具体的格式有以下一些# n# J% d' F1 e- B9 s
9 b, V$ h4 e" ^
操纵符 功能 输入/输出
* p, q, F+ |! ]; m- [0 u5 V 8 O+ `8 {! r. A8 ~4 w. Y
dec 格式化为十进制数值数据 输入和输出
/ L: Z$ @+ ^. j) z 2 ]$ y3 B) ?- c6 P! O' ?$ P
endl 输出一个换行符并刷新此流 输出* ~& d" X5 M5 o
7 ~/ B/ C. {# w' l ends 输出一个空字符 输出
4 c5 w( k4 c' V$ r4 | ' n0 {2 e) I, Q
hex 格式化为十六进制数值数据 输入和输出. e) ~2 H; l+ k! c
0 B* J- k/ r+ k9 b% } oct 格式化为八进制数值数据 输入和输出& M5 l, v7 z, j& j: R+ B
9 L1 A/ ?+ {. |( \ setpxecision(int p) 设置浮点数的精度位数 输出6 x4 Y) v- u4 Q8 K' r! F7 Q& A
# A5 k( M* w6 L* T
比如要把123当作十六进制输出:file1<
! \5 M; X- {/ H6 Z 2、二进制文件的读写9 p+ R3 N2 P T( e! y; Z- B
# g+ `9 ~/ R# J5 |3 }
①put()
( H2 S& |* A2 W3 c; F$ E, u
* [4 |# E7 y8 e' ~5 ? put()函数向流写入一个字符,其原型是ofstream &put(char ch),使用也比较简单,如file1.put('c');就是向流写一个字符'c'。" N9 B( P+ W6 K; M
" J( ^+ K) y4 b4 i3 q1 Q8 b
②get()
, h# H# I* v8 D: w$ E. B
; P4 G# b$ a9 c, V: x% [" E' { get()函数比较灵活,有3种常用的重载形式:4 h; h: c, E3 A" ]" f. W
6 E9 s4 ^; a/ f" I/ h7 ^. r/ H
一种就是和put()对应的形式:ifstream &get(char &ch);功能是从流中读取一个字符,结果保存在引用ch中,如果到文件尾,返回空字符。如file2.get(x);表示从文件中读取一个字符,并把读取的字符保存在x中。- `$ H9 U w2 E8 r) b
# {, q9 u$ m$ }0 v, r. p5 ] 另一种重载形式的原型是: int get();这种形式是从流中返回一个字符,如果到达文件尾,返回EOF,如x=file2.get();和上例功能是一样的。0 }( A4 j7 P# ~; B/ w3 I5 ]) M
- ]1 T) B; s: [0 y 还有一种形式的原型是:ifstream &get(char *buf,int num,char delim='\n');这种形式把字符读入由 buf 指向的数组,直到读入了 num 个字符或遇到了由 delim 指定的字符,如果没使用 delim 这个参数,将使用缺省值换行符'\n'。例如:2 M, \6 v( C5 `$ n& G+ n4 J
( Z9 b2 v2 h7 Y# Z) `7 ^
file2.get(str1,127,'A'); //从文件中读取字符到字符串str1,当遇到字符'A'或读取了127个字符时终止。- t* h/ F- o' z9 g" `' |6 y2 c
3 F. E+ g2 ~, y' h3 @4 T) e
③读写数据块7 _* v1 R! O9 H$ x4 g4 }9 W
& E$ Q& t' E6 B. e: c$ L4 g2 p3 v4 c 要读写二进制数据块,使用成员函数read()和write()成员函数,它们原型如下:
3 v' U5 A: m5 [ $ _# ]% x$ I5 `$ ]
read(unsigned char *buf,int num);
* G/ @6 | e7 S S% m( Q; X) G " v$ R: [7 l" X
write(const unsigned char *buf,int num);, c) ?' g1 O: E2 L4 h
2 z( S& y+ y2 Q V% q
read()从文件中读取 num 个字符到 buf 指向的缓存中,如果在还未读入 num 个字符时就到了文件尾,可以用成员函数 int gcount();来取得实际读取的字符数;而 write() 从buf 指向的缓存写 num 个字符到文件中,值得注意的是缓存的类型是 unsigned char *,有时可能需要类型转换。
Q8 G0 j2 q: R9 Y) ^. U; ]
$ b- N' `! `/ m* g5 E 例:
7 C9 i9 t$ P6 ^) W
3 K w- g7 P$ L5 { unsigned char str1[]="I Love You";& |) f2 N2 ^ o% G. x
5 w! P0 q; i d t* i+ d int n[5];
' @0 b% `5 Z4 `
0 V' R; {8 Y; x9 p8 \ ifstream in("xxx.xxx");+ ^: |3 @1 U% I& @4 h" }% _
" C% u& F- ^6 t& c3 q ofstream out("yyy.yyy");
) J2 \# E, @9 e, s! e0 p- P: b 9 z A2 B; R2 N* u$ v8 Y3 l: x2 {
out.write(str1,strlen(str1));//把字符串str1全部写到yyy.yyy中
9 `' B: l4 V- c; h! P5 M" Y' r 7 y9 w0 b1 F3 C7 H) p6 `
in.read((unsigned char*)n,sizeof(n));//从xxx.xxx中读取指定个整数,注意类型转换
; q" S1 h/ A) p* q& A5 s5 _5 V
: v% l" [% b" a* ^; q" v) `1 R in.close();out.close(); 四、检测EOF/ \$ A A7 Y, c/ x7 b7 w0 I5 T
% [5 t2 h; F& @( q7 M! [6 r 成员函数eof()用来检测是否到达文件尾,如果到达文件尾返回非0值,否则返回0。原型是int eof();% q* l" u4 r0 `! U8 ?: \ R
" L7 V& z3 [2 z( P4 v 例: if(in.eof()) ShowMessage("已经到达文件尾!");
" G1 h% p3 A1 H7 C
. [9 `+ J% T( l7 n" X1 L4 O( V 五、文件定位
8 \0 w5 }, Z8 }8 }9 [
% F- Z2 Z2 \! m- L0 i' D 和C的文件操作方式不同的是,C++ I/O系统管理两个与一个文件相联系的指针。一个是读指针,它说明输入操作在文件中的位置;另一个是写指针,它下次写操作的位置。每次执行输入或输出时,相应的指针自动变化。所以,C++的文件定位分为读位置和写位置的定位,对应的成员函数是seekg()和seekp()。seekg()是设置读位置, seekp是设置写位置。它们最通用的形式如下:
( s- ?" x& o; m7 m$ Y4 D9 {9 a* C 2 H# S, f; C# Y4 `6 y
istream &seekg(streamoff offset,seek_dir origin);
* K& L4 N& ~6 A' b+ z
! _ o3 `4 e: _/ p0 A3 z ostream &seekp(streamoff offset,seek_dir origin);
; `, W- k$ [/ l2 Q' p/ Z; X6 F" d 0 z/ w' ^; \* B; t8 G. A9 e- {5 K
streamoff定义于 iostream.h 中,定义有偏移量 offset 所能取得的最大值,seek_dir 表示移动的基准位置,是一个有以下值的枚举:
9 `( E( K2 {0 V% A- [- d 1 r" ?) ?# B9 s# o; W7 }
ios::beg: 文件开头; ~" p* ]. x3 z7 p
6 m; J$ t! `6 `+ f ios::cur: 文件当前位置$ i4 M. o- {" A. E* Z: ?. o
9 F& c1 \- E+ \ ios::end: 文件结尾
) H6 X4 r6 \4 b% j$ A
8 h5 \5 K `$ q; n% Z 这两个函数一般用于二进制文件,因为文本文件会因为系统对字符的解释而可能与预想的值不同。例:
) w- g& P& ]2 e) t ) f% d2 U# ]$ R, B) b
file1.seekg(1234,ios::cur); //把文件的读指针从当前位置向后移1234个字节- K' @6 w5 B3 B, n7 N
# \# K7 h; O2 M. p file2.seekp(1234,ios::beg); //把文件的写指针从文件开头向后移1234个字节* f* ? \+ B2 ]
6 H7 B$ y Q# R |
|