- 在线时间
- 0 小时
- 最后登录
- 2007-9-23
- 注册时间
- 2004-9-10
- 听众数
- 3
- 收听数
- 0
- 能力
- 0 分
- 体力
- 9975 点
- 威望
- 7 点
- 阅读权限
- 150
- 积分
- 4048
- 相册
- 0
- 日志
- 0
- 记录
- 0
- 帖子
- 1893
- 主题
- 823
- 精华
- 2
- 分享
- 0
- 好友
- 0
我的地盘我做主
该用户从未签到
|
< align=left><FONT color=#cc0000><B>文件
4 f9 N% N/ Y/ Q
5 i5 F+ s3 g6 R6 g</B></FONT><FONT color=#ff0000>文件的基本概念</FONT>
, c. Y. n' }0 W' |2 _( Y2 i 所谓“文件”是指一组相关数据的有序集合。 这个数据集有一个名称，叫做文件名。 实际上在前面的各章中我们已经多次使用了文件，例如源程序文件、目标文件、可执行文件、库文件 (头文件)等。文件通常是驻留在外部介质(如磁盘等)上的， 在使用时才调入内存中来。从不同的角度可对文件作不同的分类。从用户的角度看，文件可分为普通文件和设备文件两种。
4 r" e, N; b' p% l5 @7 E. L! |: N; H& b; X9 h3 d9 u: Y
普通文件是指驻留在磁盘或其它外部介质上的一个有序数据集，可以是源文件、目标文件、可执行程序； 也可以是一组待输入处理的原始数据，或者是一组输出的结果。对于源文件、目标文件、 可执行程序可以称作程序文件，对输入输出数据可称作数据文件。
& |" R: {3 u3 p3 b
* t" c# T* J$ N4 t; r& x2 n 设备文件是指与主机相联的各种外部设备，如显示器、打印机、键盘等。在操作系统中，把外部设备也看作是一个文件来进行管理，把它们的输入、输出等同于对磁盘文件的读和写。 通常把显示器定义为标准输出文件， 一般情况下在屏幕上显示有关信息就是向标准输出文件输出。如前面经常使用的printf,putchar 函数就是这类输出。键盘通常被指定标准的输入文件， 从键盘上输入就意味着从标准输入文件上输入数据。scanf,getchar函数就属于这类输入。 4 h6 ?1 y" B, h; d. X
' k W* ]; E! O. E$ o% P2 Q 从文件编码的方式来看，文件可分为ASCII码文件和二进制码文件两种。
: N+ ~; r/ z' `8 b* O6 J8 \/ S' T- V# d% |
ASCII文件也称为文本文件，这种文件在磁盘中存放时每个字符对应一个字节，用于存放对应的ASCII码。例如，数5678的存储形式为：
6 F" R0 e0 ]) e O# c, R( qASC码： 00110101 00110110 00110111 00111000/ A3 i$ X4 W2 y4 {6 l$ G' {
↓ ↓ ↓ ↓
$ I( P1 S7 o% j3 |十进制码： 5 6 7 8 共占用4个字节。ASCII码文件可在屏幕上按字符显示， 例如源程序文件就是ASCII文件，用DOS命令TYPE可显示文件的内容。 由于是按字符显示，因此能读懂文件内容。
- z3 n! U8 R' |9 `; l- ?) T I: q9 n
! a' |# L$ }, h$ p I" P 二进制文件是按二进制的编码方式来存放文件的。 例如， 数5678的存储形式为： 00010110 00101110只占二个字节。二进制文件虽然也可在屏幕上显示， 但其内容无法读懂。C系统在处理这些文件时，并不区分类型，都看成是字符流，按字节进行处理。 输入输出字符流的开始和结束只由程序控制而不受物理符号(如回车符)的控制。 因此也把这种文件称作“流式文件”。+ L6 Q A" ]' @. K! v# L4 N
3 ?# ]0 p# |; a" C' B# a 本章讨论流式文件的打开、关闭、读、写、 定位等各种操作。文件指针在Ｃ语言中用一个指针变量指向一个文件， 这个指针称为文件指针。通过文件指针就可对它所指的文件进行各种操作。 定义说明文件指针的一般形式为： FILE* 指针变量标识符； 其中FILE应为大写，它实际上是由系统定义的一个结构， 该结构中含有文件名、文件状态和文件当前位置等信息。 在编写源程序时不必关心FILE结构的细节。例如：FILE *fp； 表示fp是指向FILE结构的指针变量，通过fp 即可找存放某个文件信息的结构变量，然后按结构变量提供的信息找到该文件， 实施对文件的操作。习惯上也笼统地把fp称为指向一个文件的指针。文件的打开与关闭文件在进行读写操作之前要先打开，使用完毕要关闭。 所谓打开文件，实际上是建立文件的各种有关信息， 并使文件指针指向该文件，以便进行其它操作。关闭文件则断开指针与文件之间的联系，也就禁止再对该文件进行操作。# l& T$ i3 \# c! w
+ H/ I7 U' F- ]5 I2 t( G
在Ｃ语言中，文件操作都是由库函数来完成的。 在本章内将介绍主要的文件操作函数。/ C" h) e3 \2 i: [# ?) F2 m
& g' c' t* x' z" d<FONT color=#ff0000>文件打开函数ｆｏｐｅｎ</FONT>
" H8 Y. { ]2 e9 }1 F
; ^+ B# Y( |5 A5 D( G fopen函数用来打开一个文件，其调用的一般形式为： 文件指针名=fopen(文件名，使用文件方式) 其中，“文件指针名”必须是被说明为FILE 类型的指针变量，“文件名”是被打开文件的文件名。 “使用文件方式”是指文件的类型和操作要求。“文件名”是字符串常量或字符串数组。例如： 2 b6 e! J6 p) s9 u4 r, g
<FONT color=#009900>FILE *fp；
" }% [- C7 [8 s# V4 S; a. p8 Ifp=("file a","r");</FONT>
( U6 x: M5 f+ \# N" e* h其意义是在当前目录下打开文件file a， 只允许进行“读”操作，并使fp指向该文件。2 A" j2 J& `5 H( x' C2 q3 A
又如：0 T3 Y' b" e4 }! B' G
<FONT color=#009900>FILE *fphzk
% S: h+ z- m, ]$ M7 t) g; N3 d! D2 rfphzk=("c:\\hzk16',"rb")</FONT>3 h) S+ Q0 v8 T- J! L# l( i& w/ o
其意义是打开C驱动器磁盘的根目录下的文件hzk16， 这是一个二进制文件，只允许按二进制方式进行读操作。两个反斜线“\\ ”中的第一个表示转义字符，第二个表示根目录。使用文件的方式共有12种，下面给出了它们的符号和意义。 * m# L- p2 B5 `; P
文件使用方式 意 义
4 n, n! _; [8 H6 w<FONT color=#009900>“rt” 只读打开一个文本文件，只允许读数据
6 K/ N* K& B' |“wt” 只写打开或建立一个文本文件，只允许写数据
* Y R$ J) x1 B“at” 追加打开一个文本文件，并在文件末尾写数据
# `/ w" ]8 Q$ l7 t! V“rb” 只读打开一个二进制文件，只允许读数据! ?1 s3 v; ` v9 ^
“wb” 只写打开或建立一个二进制文件，只允许写数据
( R( u% t6 Z, d3 y8 J' P2 l# ^“ab” 追加打开一个二进制文件，并在文件末尾写数据. w' N; {7 X+ a9 W, E$ |
“rt+” 读写打开一个文本文件，允许读和写
) g! `2 b1 y$ o' T3 J“wt+” 读写打开或建立一个文本文件，允许读写) X! \4 y8 Q5 g. x
“at+” 读写打开一个文本文件，允许读，或在文件末追加数 据- y' [' K5 L; v& g2 r4 z
“rb+” 读写打开一个二进制文件，允许读和写
) Q5 d3 S2 s6 }. B“wb+” 读写打开或建立一个二进制文件，允许读和写5 w! K& m3 h4 |# s
“ab+” 读写打开一个二进制文件，允许读，或在文件末追加数据
& Y9 B3 Q1 R" n! p; R' o! ?</FONT>: N3 H( m# j& A) o6 l
对于文件使用方式有以下几点说明：
( {; P/ p: b9 v- J' X# w1. 文件使用方式由r,w,a,t,b，+六个字符拼成，各字符的含义是：# M# y' `0 v! K7 T l! x1 H: a
r(read): 读6 ` H) g o u; c' s& U9 H3 V Y
w(write): 写/ p, Z& v' o* v( E* c
a(append): 追加7 D: V3 B4 n }" L
t(text): 文本文件，可省略不写- U, }. H5 x1 u2 U' w
b(banary): 二进制文件& A% R6 ]/ r' I4 T/ S6 h
+: 读和写
6 W+ l8 N( v# }3 I1 F; j/ N% \1 H( k1 ^ O
2. 凡用“r”打开一个文件时，该文件必须已经存在， 且只能从该文件读出。
5 |: p6 k a' O$ G/ ?7 |5 M. Q* y2 o: c, q! q
3. 用“w”打开的文件只能向该文件写入。 若打开的文件不存在，则以指定的文件名建立该文件，若打开的文件已经存在，则将该文件删去，重建一个新文件。
$ A: m |+ t" Y" t1 a/ Q6 }
; u+ B6 ?; |7 J2 X' ~# G4. 若要向一个已存在的文件追加新的信息，只能用“a ”方式打开文件。但此时该文件必须是存在的，否则将会出错。& c* Q2 g% _ D
* W& I! c3 H4 ]1 w+ V- G( g5. 在打开一个文件时，如果出错，fopen将返回一个空指针值NULL。在程序中可以用这一信息来判别是否完成打开文件的工作，并作相应的处理。因此常用以下程序段打开文件：/ u: X4 B! I0 l4 D. T( d
<FONT color=#009900>if((fp=fopen("c:\\hzk16","rb")==NULL): A9 q$ ?, D9 Q7 h0 _
{8 |. T) B& h. s
printf("\nerror on open c:\\hzk16 file!");
' \- j" @1 u5 q4 @' Igetch();
4 m' O3 ?/ q' x% B7 rexit(1);0 b ? f$ ~ N
}
& G4 J1 ?/ `' b4 y+ ^4 r</FONT> 这段程序的意义是，如果返回的指针为空，表示不能打开C盘根目录下的hzk16文件，则给出提示信息“error on open c:\ hzk16file!”，下一行getch()的功能是从键盘输入一个字符，但不在屏幕上显示。在这里，该行的作用是等待， 只有当用户从键盘敲任一键时，程序才继续执行， 因此用户可利用这个等待时间阅读出错提示。敲键后执行exit(1)退出程序。. Z; Y0 |7 y2 n1 s, v5 c- b% {
9 b( X2 ~' O, E! j6. 把一个文本文件读入内存时，要将ASCII码转换成二进制码， 而把文件以文本方式写入磁盘时，也要把二进制码转换成ASCII码，因此文本文件的读写要花费较多的转换时间。对二进制文件的读写不存在这种转换。+ @3 f) E ^1 f+ N; t. b+ o
% c: b' n4 Q. k. x5 }1 R7. 标准输入文件(键盘)，标准输出文件(显示器 )，标准出错输出(出错信息)是由系统打开的，可直接使用。文件关闭函数ｆｃｌｏｓｅ文件一旦使用完毕，应用关闭文件函数把文件关闭， 以避免文件的数据丢失等错误。
! a. `: K9 T$ w2 G* L
: W7 ^% Y! n# K4 \7 j<FONT color=#ff0000>fclose函数3 Q& g3 F3 ~2 S' \/ V
$ U: n' s4 ?$ a% I5 k
</FONT>调用的一般形式是： fclose(文件指针)； 例如：
' I. K- r- i) M7 efclose(fp); 正常完成关闭文件操作时，fclose函数返回值为0。如返回非零值则表示有错误发生。文件的读写对文件的读和写是最常用的文件操作。
( l( C2 [, A7 C, B
: F; H* G" o% E/ l/ u( z在Ｃ语言中提供了多种文件读写的函数：
i( s# e( f) w3 T3 ~·字符读写函数 ：fgetc和fputc
: ], w: q# C0 P! r. f·字符串读写函数：fgets和fputs
/ @% Z& m& Q# P- ~. x/ ~·数据块读写函数：freed和fwrite) d" V+ r, t5 A, r
·格式化读写函数：fscanf和fprinf
6 H# X% I5 z. o) d; b. Q w; ^
+ b3 j( e' u4 K 下面分别予以介绍。使用以上函数都要求包含头文件stdio.h。字符读写函数ｆｇｅｔｃ和ｆｐｕｔｃ字符读写函数是以字符(字节)为单位的读写函数。 每次可从文件读出或向文件写入一个字符。
- L, }- o n& \/ s* f! \4 T8 z( W7 \
<FONT color=#ff0000>一、读字符函数fgetc</FONT>
- @! s0 i6 j1 R7 i2 h7 S+ C/ ]
0 g1 F, B5 h4 G+ M, x: x fgetc函数的功能是从指定的文件中读一个字符，函数调用的形式为： 字符变量=fgetc(文件指针)； 例如：ch=fgetc(fp);其意义是从打开的文件fp中读取一个字符并送入ch中。9 r" D, J$ v" ~1 ]
+ D5 R& p" w+ x& n4 S 对于fgetc函数的使用有以下几点说明：' c9 O" b8 \0 o. i0 ^3 k' ?
1. 在fgetc函数调用中，读取的文件必须是以读或读写方式打开的。
4 c7 ^2 J* \: S( T; _! s- p. A+ V$ R8 L |
2. 读取字符的结果也可以不向字符变量赋值，例如：fgetc(fp);但是读出的字符不能保存。* V1 ?; m0 G- k3 R
! d' O* D1 P f" M1 ?: r- Z3. 在文件内部有一个位置指针。用来指向文件的当前读写字节。在文件打开时，该指针总是指向文件的第一个字节。使用fgetc 函数后， 该位置指针将向后移动一个字节。 因此可连续多次使用fgetc函数，读取多个字符。 应注意文件指针和文件内部的位置指针不是一回事。文件指针是指向整个文件的，须在程序中定义说明，只要不重新赋值，文件指针的值是不变的。文件内部的位置指针用以指示文件内部的当前读写位置，每读写一次，该指针均向后移动，它不需在程序中定义说明，而是由系统自动设置的。5 s3 D1 y* ~2 `8 ^) d; l0 D9 o
/ c: }. [" B& _: m, {1 v<FONT color=#ff00ff><B>[例10.1]</B></FONT>读入文件e10-1.c，在屏幕上输出。
) u; Q) l S! W4 I<FONT color=#009900>#include<stdio.h>
P* M% n h6 @main()/ p: f7 w; B& a3 \ z
{
" \$ ]3 K$ }& w: {, O, sFILE *fp;
Q+ f1 T' D Z& Q8 c8 R5 L/ @! Schar ch;
2 |# d" g1 G8 Aif((fp=fopen("e10_1.c","rt"))==NULL)
3 Y f) j. K, i/ N{
9 _3 K& f& x- }5 d9 R5 Y' L8 Kprintf("Cannot open file strike any key exit!");
4 P, }4 x+ I9 s: C4 k6 {/ m: [ Mgetch();8 W9 M) m% G" E. a% Q
exit(1);: Z0 }+ V: W( b$ {3 \, ]
}
- J; H& j1 Z2 g B' @ch=fgetc(fp);
, r$ r/ _3 Q/ a( N1 G' bwhile (ch!=EOF)- ~: c+ m; v$ F* L' s8 ?
{) _+ K! s% H" C" D7 d
putchar(ch);
" ?9 w( x4 ?. Ych=fgetc(fp);- k8 W6 V P+ r6 P. {5 ~8 W
}
i, u" l% c* {, ofclose(fp);0 K6 K5 _; ]2 f3 G; x
}</FONT>$ R! Z' _$ |" m) b* S
本例程序的功能是从文件中逐个读取字符，在屏幕上显示。 程序定义了文件指针fp,以读文本文件方式打开文件“e10_1.c”， 并使fp指向该文件。如打开文件出错， 给出提示并退出程序。程序第12行先读出一个字符，然后进入循环， 只要读出的字符不是文件结束标志(每个文件末有一结束标志EOF)就把该字符显示在屏幕上，再读入下一字符。每读一次，文件内部的位置指针向后移动一个字符，文件结束时，该指针指向EOF。执行本程序将显示整个文件。
. e7 }0 W3 G' ~8 p0 x2 H4 _8 B* b: g
<FONT color=#ff0000>二、写字符函数fputc</FONT>0 ]) N- Z3 v0 k" M3 A
0 ?8 B* N9 \# |+ X/ a, e! l fputc函数的功能是把一个字符写入指定的文件中，函数调用的 形式为： fputc(字符量，文件指针)； 其中，待写入的字符量可以是字符常量或变量，例如：fputc('a',fp);其意义是把字符a写入fp所指向的文件中。: T O+ v3 b" [! I2 C0 Y% t, n' ?
' _5 l! N, F [* {% P' u' U
对于fputc函数的使用也要说明几点：& G/ ]% O# W' ~& A$ d R& T ~
1. 被写入的文件可以用、写、读写，追加方式打开，用写或读写方式打开一个已存在的文件时将清除原有的文件内容，写入字符从文件首开始。如需保留原有文件内容，希望写入的字符以文件末开始存放，必须以追加方式打开文件。被写入的文件若不存在，则创建该文件。
6 b/ o( H/ m: u& L! t
9 o" w) S7 J3 \, ^2. 每写入一个字符，文件内部位置指针向后移动一个字节。
8 y8 W9 u/ P& {- K, b: r
# u4 Z4 _. B; ?* |7 Y/ m3. fputc函数有一个返回值，如写入成功则返回写入的字符， 否则返回一个EOF。可用此来判断写入是否成功。7 V% Q0 N# h+ i# P4 O: `
, E) \" N7 F- L
<FONT color=#ff00ff><B>[例10.2]</B></FONT>从键盘输入一行字符，写入一个文件， 再把该文件内容读出显示在屏幕上。4 w5 j4 v; e8 m
<FONT color=#009900>#include<stdio.h>: J p7 `* D+ Q+ O5 ?. {( z
main()* k( f+ [/ \% n) Q+ w
{
0 d# {% M3 D1 I. I! ZFILE *fp;
, l y) Q- A( Z' r) hchar ch;
# [8 h4 y, ^7 Y$ k/ r" o& i6 Bif((fp=fopen("string","wt+"))==NULL)
1 {( V/ H _" q: k, k0 R{6 {0 k9 H* w8 P9 c
printf("Cannot open file strike any key exit!");
* R0 u$ u$ e- L' N( i* n h# pgetch();( M" Y* N6 \) O2 U
exit(1);
S1 i* r( X( a0 m}
4 V6 H5 l7 z9 X4 k1 F l! @printf("input a string:\n");
0 Y6 I+ I2 n" M- z9 Jch=getchar();
9 w# E0 t' q/ owhile (ch!='\n')
+ e/ N2 t ~5 ^; T1 |5 @{4 J2 S( R1 C7 y
fputc(ch,fp);& P( L# x- j1 ^9 A
ch=getchar();9 _$ [0 M- _* m
}
9 w# j/ x1 H, F. c6 d) F$ Krewind(fp);
: D* _# a4 P1 u$ Z7 I5 U) D1 A; Vch=fgetc(fp);
6 `7 G" a5 C# ~ i, Zwhile(ch!=EOF)1 z* P4 B" W% i7 t% U) q
{
; g: K$ @. q9 l6 K/ B6 h$ Z& D! sputchar(ch);7 T! u9 p1 g0 D- ]! f' I6 Z/ o
ch=fgetc(fp);0 I) `# n! a3 x5 \' z( u& w
}
* _9 {+ D4 H7 _. d% B; R: y' H( uprintf("\n");
4 X& q# }6 h5 @- S; [1 \. dfclose(fp);5 L4 ?6 `7 p6 z0 a% Y/ C: H& T' c4 g
}</FONT>* h( K% ]/ W2 Z+ Q9 \/ ]
程序中第6行以读写文本文件方式打开文件string。程序第13行从键盘读入一个字符后进入循环，当读入字符不为回车符时， 则把该字符写入文件之中，然后继续从键盘读入下一字符。 每输入一个字符，文件内部位置指针向后移动一个字节。写入完毕， 该指针已指向文件末。如要把文件从头读出，须把指针移向文件头， 程序第19行rewind函数用于把fp所指文件的内部位置指针移到文件头。 第20至25行用于读出文件中的一行内容。5 S1 @2 R! C4 f; o) n! M: ?, N
: `1 S) ~- C; @/ t# e<FONT color=#ff00ff><B>[例10.3]</B></FONT>把命令行参数中的前一个文件名标识的文件， 复制到后一个文件名标识的文件中， 如命令行中只有一个文件名则把该文件写到标准输出文件(显示器)中。
2 a9 {8 W% x7 G1 {% `<FONT color=#009900>#include<stdio.h>2 q( c4 L* C5 }7 q0 L
main(int argc,char *argv[])0 i& g# P$ \- V2 F! u
{
! \1 _! R% t8 ^. k6 K- u/ EFILE *fp1,*fp2;
+ I3 J \0 `. F9 }: bchar ch;8 a/ ^5 q. v N$ n% t; Z* k* l
if(argc==1)8 i9 e V! v$ h: S4 O. v
{
4 x* r+ L+ u2 ^; y1 ~7 S- }printf("have not enter file name strike any key exit");
5 j7 O5 Z, V: t) G5 H1 z* M. n" {getch();: |; }# c; f+ d/ o
exit(0);
, r5 x' J/ {: `/ W3 y# k}% Y' E7 r' E' v( p! @9 z
if((fp1=fopen(argv[1],"rt"))==NULL)& W1 _+ a2 {- N( Z+ n/ c6 V* i2 N
{/ \) n# z- X3 v) J: N
printf("Cannot open %s\n",argv[1]);
- Y5 V) `3 ~( D6 P% Ygetch();
( d' b% r( n" A3 y5 H0 O) Mexit(1);7 C) {0 f0 P# d" |8 m
}
8 Y/ z m; M: w0 P1 X( k6 n% _if(argc==2) fp2=stdout;' t L1 g3 [2 S8 b/ d
else if((fp2=fopen(argv[2],"wt+"))==NULL)( I: |- ~' n$ F! f& h
{
% N7 ~+ s0 r8 d' e2 ?printf("Cannot open %s\n",argv[1]);* ^& V* V$ N7 c1 Q4 l
getch();
5 S# Z& v0 z0 L! |. O! G& ]& g& z, ]exit(1);
# W( s, z0 D) C9 Y' P Q5 Z' @}4 U& \ M! [& F( E& k" Z$ L6 c' F
while((ch=fgetc(fp1))!=EOF)0 _/ F* n S4 E8 _ f
fputc(ch,fp2);
* G, B! F) Z( | \2 G/ X! jfclose(fp1);
' X$ q( R6 k/ v+ j' z5 Kfclose(fp2);+ Y0 _% a* Q! ]# F
}</FONT>9 p: v8 Y1 @5 u
本程序为带参的main函数。程序中定义了两个文件指针 fp1 和fp2，分别指向命令行参数中给出的文件。如命令行参数中没有给出文件名，则给出提示信息。程序第18行表示如果只给出一个文件名，则使fp2指向标准输出文件(即显示器)。程序第25行至28行用循环语句逐个读出文件1中的字符再送到文件2中。再次运行时，给出了一个文件名(由例10.2所建立的文件)， 故输出给标准输出文件stdout，即在显示器上显示文件内容。第三次运行，给出了二个文件名，因此把string中的内容读出，写入到OK之中。可用DOS命令type显示OK的内容：字符串读写函数ｆｇｅｔｓ和ｆｐｕｔｓ
4 Z/ r ? ?# M
" ^" s. e4 m2 c- W/ [一、<FONT color=#ff0000>读字符串函数fgets函数</FONT>的功能是从指定的文件中读一个字符串到字符数组中，函数调用的形式为： fgets(字符数组名，n，文件指针)； 其中的n是一个正整数。表示从文件中读出的字符串不超过 n-1个字符。在读入的最后一个字符后加上串结束标志'\0'。例如：fgets(str,n,fp);的意义是从fp所指的文件中读出n-1个字符送入字符数组str中。
3 s" o: h: Z J) m<B><FONT color=#ff00ff>[例10.4]</FONT></B>从e10_1.c文件中读入一个含10个字符的字符串。% X* Q8 x# x8 J" k3 I' e
<FONT color=#009900>#include<stdio.h>
( J2 v2 `: ~& b# {main()
E% W0 x0 u- u4 V) P3 B) ?{
, m+ T) L3 z; G) Q& WFILE *fp;& j z* e' I1 Z
char str[11];
+ Q& a1 I! d0 u0 Dif((fp=fopen("e10_1.c","rt"))==NULL)
/ {3 S7 L# m( C3 m2 n9 H{5 i/ _% _0 \* |- i, T
printf("Cannot open file strike any key exit!");
* r: v; A1 @2 bgetch();- P$ I6 O! a& z9 f
exit(1);
% S$ D; X |6 H2 B F' A}2 M3 c9 G% n, q0 z5 z g- Y
fgets(str,11,fp);
j6 f; h! W# L5 s9 \+ g) g' N! @printf("%s",str);
. x' |7 B. }+ r0 J2 T% |2 jfclose(fp);6 I6 y" m; V, ?) {8 ~
}</FONT>
- I+ S# ^5 s: A 本例定义了一个字符数组str共11个字节，在以读文本文件方式打开文件e101.c后，从中读出10个字符送入str数组，在数组最后一个单元内将加上'\0'，然后在屏幕上显示输出str数组。输出的十个字符正是例10.1程序的前十个字符。% p& ~* i2 _) w) ?, ]5 P Q
' z, m; P1 q* A, a 对fgets函数有两点说明：
6 I3 m% o2 m. n1. 在读出n-1个字符之前，如遇到了换行符或EOF，则读出结束。9 j0 I" f" ^" |$ {/ @( D
2. fgets函数也有返回值，其返回值是字符数组的首地址。
2 l6 U5 e) T6 l
- s" o1 C2 ?# s: U7 W5 t<FONT color=#ff0000>二、写字符串函数fputs</FONT>* M6 R1 H8 a1 K1 W
$ M7 h( e; U2 D* K( [1 {) z0 Hfputs函数的功能是向指定的文件写入一个字符串，其调用形式为： fputs(字符串，文件指针) 其中字符串可以是字符串常量，也可以是字符数组名， 或指针 变量，例如：
% J) o7 _2 {) f7 I& I- s# s, @, Qfputs(“abcd“，fp)；
/ k- C! Q& ]0 o4 w其意义是把字符串“abcd”写入fp所指的文件之中。[例10.5]在例10.2中建立的文件string中追加一个字符串。
1 U7 j1 G+ B7 z8 g' K<FONT color=#009900>#include<stdio.h>
. g( @: y4 S8 u" n0 I( umain()2 v' V: D' M4 w! E. }. W; D
{
$ S& B" M8 W, U6 cFILE *fp;
) _( i* `& m0 n: q4 M" k8 i2 ^char ch,st[20];1 }4 N: _9 W( W$ W
if((fp=fopen("string","at+"))==NULL)
A! D8 H8 E$ }( K0 @7 |{
- Y- V0 I& _5 b7 R1 c7 {4 ^printf("Cannot open file strike any key exit!");
9 N# ^0 B2 d& }; _getch();4 b5 Y% ]* K7 b- {1 s
exit(1);7 ^! a4 A$ |- y# A( u! y
}$ B( O9 N; \% F
printf("input a string:\n");
( Y! r3 P* X2 |6 ]' yscanf("%s",st);
% H" ^% ^+ S6 u, ]: e: X$ V5 |% o, ~fputs(st,fp);8 W9 z# Z8 Z- T+ Q9 q; h' H8 |$ e
rewind(fp);# i$ Q4 g% Q( n0 [; [" x
ch=fgetc(fp);( g v% e$ G7 |
while(ch!=EOF)
0 W! \* s1 k7 G4 F0 l{
% N. \) V. w( yputchar(ch);# G" D( r9 W/ _: _( F% O8 @8 X
ch=fgetc(fp);
4 X/ r2 q; {' ?0 U* Q}' e. W* R/ \8 X n9 z m, P' O3 Z: e
printf("\n");
( h9 J/ L$ r: d. S6 }; Jfclose(fp);
" z% }; {% f" m6 u) j+ g: O}</FONT>
5 t- W' L4 h+ I, Z6 w. x! ]% n 本例要求在string文件末加写字符串，因此，在程序第6行以追加读写文本文件的方式打开文件string 。 然后输入字符串， 并用fputs函数把该串写入文件string。在程序15行用rewind函数把文件内部位置指针移到文件首。 再进入循环逐个显示当前文件中的全部内容。
3 R& Y" b6 q7 M z" M$ m5 t l4 u4 [( r. |( j
<FONT color=#ff0000>数据块读写函数ｆｒｅａｄ和ｆｗｒｉｔｅ</FONT>2 v3 ?& U& A7 g
5 m8 [6 @' v" d; M7 O/ O
Ｃ语言还提供了用于整块数据的读写函数。 可用来读写一组数据，如一个数组元素，一个结构变量的值等。读数据块函数调用的一般形式为： fread(buffer,size,count,fp); 写数据块函数调用的一般形式为： fwrite(buffer,size,count,fp); 其中buffer是一个指针，在fread函数中，它表示存放输入数据的首地址。在fwrite函数中，它表示存放输出数据的首地址。 size 表示数据块的字节数。count 表示要读写的数据块块数。fp 表示文件指针。
- y' W$ A) N. ~; ?) Z例如：
5 {1 T( E% j5 I4 M8 ifread(fa,4,5,fp); 其意义是从fp所指的文件中，每次读4个字节(一个实数)送入实数组fa中，连续读5次，即读5个实数到fa中。
9 a& B3 g. Q6 u& A[例10.6]从键盘输入两个学生数据，写入一个文件中， 再读出这两个学生的数据显示在屏幕上。5 `$ t# ~( _" N& F2 [
<FONT color=#009900>#include<stdio.h>
5 N6 u' |2 k2 Gstruct stu- [ o( J" g7 C
{
, { U$ c. t# d: Z- gchar name[10];
5 f# ]% f8 R$ \5 o# e5 S4 nint num;
. _9 o4 B9 a% C& X: d8 Oint age;" d$ F3 T7 w+ ~+ I1 P- j
char addr[15];3 t# a" D, a% q( F7 J+ S* q+ T2 o" N
}boya[2],boyb[2],*pp,*qq;# C* t1 ~8 b2 r5 Z
main()
' r' O% P0 T5 n$ E' a S{& q/ W' }. b8 A* {# _" ]
FILE *fp;: Z6 }; ? M% P4 s$ u4 U
char ch;1 w6 w$ Z7 m1 P- z4 R
int i;: z; g+ y+ w2 Z0 {
pp=boya;+ ^: {( V7 h: }) K) S% u$ w4 |
qq=boyb;$ x- T7 N4 q/ i) ~- Z* U+ u
if((fp=fopen("stu_list","wb+"))==NULL), e& a0 x" E2 u7 @# q% O
{2 q5 T/ Q. B* L- ^' o5 m* ~% D
printf("Cannot open file strike any key exit!");
( H e0 A7 o% T3 E) [getch();
0 y' D4 Q4 y8 ^8 J" y7 Zexit(1);+ e4 f( @: L E8 q/ o
}5 }; W I }' l0 G
printf("\ninput data\n"); J8 }. ?0 k1 J7 W9 f. r" b6 V
for(i=0;i<2;i++,pp++)
; p8 ]- V6 z# h( y* ?scanf("%s%d%d%s",pp->name,&pp->num,&pp->age,pp->addr);
! D" L$ x" X9 r( [4 M2 @0 C, Jpp=boya;+ l& r/ C/ \# h
fwrite(pp,sizeof(struct stu),2,fp);4 B9 o1 R0 u. F/ `% Q# o4 H; R
rewind(fp);
8 @1 h8 _. `# ~2 n7 B- ifread(qq,sizeof(struct stu),2,fp);
7 f3 K% l, N" e9 ]- F* a# [% S* vprintf("\n\nname\tnumber age addr\n");
5 U0 ~& g+ {) r9 v# ufor(i=0;i<2;i++,qq++) n. @2 u/ |& ]* F; q* O2 Y/ G
printf("%s\t%5d%7d%s\n",qq->name,qq->num,qq->age,qq->addr);
: v+ _/ r2 a8 j8 i h2 Nfclose(fp);) @: R: _) I3 B8 ^* ^' Q* b M( t
}</FONT>
3 @+ q. k. _; ]5 t9 c! r1 m 本例程序定义了一个结构stu,说明了两个结构数组boya和 boyb以及两个结构指针变量pp和qq。pp指向boya,qq指向boyb。程序第16行以读写方式打开二进制文件“stu_list”，输入二个学生数据之后，写入该文件中， 然后把文件内部位置指针移到文件首，读出两块学生数据后，在屏幕上显示。$ X# {/ S% }$ ?- N. k- K
! Y1 a( L0 C: C# I5 R
<FONT color=#ff0000>格式化读写函数ｆｓｃａｎｆ和ｆｐｒｉｎｔｆ</FONT>
& r( g' F& L5 u7 W6 n
! M. ?0 M3 X' i8 l% p/ @( hfscanf函数，fprintf函数与前面使用的scanf和printf 函数的功能相似，都是格式化读写函数。 两者的区别在于 fscanf 函数和fprintf函数的读写对象不是键盘和显示器，而是磁盘文件。这两个函数的调用格式为： fscanf(文件指针，格式字符串，输入表列)； fprintf(文件指针，格式字符串，输出表列)； 例如：6 o+ l" m+ Q- X5 L7 S7 K" r5 {
fscanf(fp,"%d%s",&i,s);3 a& b) }1 N& D' r7 ?
fprintf(fp,"%d%c",j,ch);
7 d7 L$ m0 |% ^用fscanf和fprintf函数也可以完成例10.6的问题。修改后的程序如例10.7所示。
% G# A( f5 P7 w8 m[例10.7]3 E" [; r3 c8 {. A+ q
<FONT color=#009900>#include<stdio.h>. T* X. i7 y* f- D! ~4 L
struct stu2 a# x+ O, B# O D7 z( ?& F
{
( \$ N+ }7 W+ ? C6 m, Xchar name[10];
& K5 y& r0 G E5 r1 W( d5 lint num;
" }$ U ?2 L: i! H( ?! }int age;- F' ?! I4 | C0 }) K8 U5 G8 B4 x
char addr[15];
' C0 r4 x! y" k( I( ?. i7 c, W# ?1 M}boya[2],boyb[2],*pp,*qq;
- f3 d. g* O8 pmain()! l! |/ T2 p( `& q) U( `4 \# N
{7 ?9 V4 g1 C- |9 m& n1 ~
FILE *fp;
6 L1 p5 E( f( ?. ~# a8 Cchar ch;) h1 I; t9 @# J. F+ {
int i;
% i5 _9 f( r/ }! Q& N( ^pp=boya;, c' f0 Y4 @4 n$ v }
qq=boyb;
1 I, X* u! _- W5 e# ^4 Oif((fp=fopen("stu_list","wb+"))==NULL)2 h( O7 b3 q4 x
{7 ^2 Q, I( R8 Q! ]7 c% f
printf("Cannot open file strike any key exit!");
) i! h0 w- f ngetch();
' I8 x5 u2 s- H, ]; w" wexit(1);+ n1 @) y; Y; v& M, V
}
/ ^7 s9 M, _+ V/ Tprintf("\ninput data\n");
# G4 @6 J& u x- ?for(i=0;i<2;i++,pp++); t* y6 F# f: n& _3 C+ d" O
scanf("%s%d%d%s",pp->name,&pp->num,&pp->age,pp->addr);
# h: _' d' z3 f! D# lpp=boya;
' n* Y" R9 |6 ]5 [$ Pfor(i=0;i<2;i++,pp++)
& y6 b1 {7 o/ Y9 {! v& t7 Mfprintf(fp,"%s %d %d %s\n",pp->name,pp->num,pp->age,pp->
, o+ n/ u& G, t, ~! taddr);9 K3 P2 g6 n8 ^% U6 E
rewind(fp);
! h4 v. R6 B, P* ]2 q, I! H1 nfor(i=0;i<2;i++,qq++)
# P& P4 i2 w- T' [, M; [. H/ ?fscanf(fp,"%s %d %d %s\n",qq->name,&qq->num,&qq->age,qq->addr);
8 b( l4 k# e9 |" Z5 s9 D( x/ D2 \printf("\n\nname\tnumber age addr\n");
2 M. f. p0 n5 C, w* Uqq=boyb;
, X- i8 Z! W/ S8 @+ A+ sfor(i=0;i<2;i++,qq++)0 ]7 u$ z0 h& W: X
printf("%s\t%5d %7d %s\n",qq->name,qq->num, qq->age,0 S5 E( [' M9 B, \
qq->addr);
& g/ s0 @7 T3 [' G' ?fclose(fp);
3 H! u( W1 S1 P, d3 A6 S}</FONT>+ v4 o2 e6 I7 ]2 R
与例10.6相比，本程序中fscanf和fprintf函数每次只能读写一个结构数组元素，因此采用了循环语句来读写全部数组元素。 还要注意指针变量pp,qq由于循环改变了它们的值，因此在程序的25和32行分别对它们重新赋予了数组的首地址。
3 _. k% C! d% L
. w" W v1 Q3 a9 o( X1 V<FONT color=#ff0000>文件的随机读写</FONT>3 X2 X' m9 g! u5 |0 N1 L
; Q0 M6 _: T% N
前面介绍的对文件的读写方式都是顺序读写， 即读写文件只能从头开始，顺序读写各个数据。 但在实际问题中常要求只读写文件中某一指定的部分。 为了解决这个问题可移动文件内部的位置指针到需要读写的位置，再进行读写，这种读写称为随机读写。 实现随机读写的关键是要按要求移动位置指针，这称为文件的定位。文件定位移动文件内部位置指针的函数主要有两个， 即 rewind 函数和fseek函数。- _6 r o- w8 O5 v8 F
, ~9 V. m. w1 x5 |0 P8 k/ B
rewind函数前面已多次使用过，其调用形式为： rewind(文件指针)； 它的功能是把文件内部的位置指针移到文件首。 下面主要介绍
' o" i5 z5 F6 x5 e5 w" kfseek函数。
* D, I' x2 ?, T- J" l7 ]* K8 y. A3 r- c( H V0 P% g+ K
fseek函数用来移动文件内部位置指针，其调用形式为： fseek(文件指针，位移量，起始点)； 其中：“文件指针”指向被移动的文件。 “位移量”表示移动的字节数，要求位移量是long型数据，以便在文件长度大于64KB 时不会出错。当用常量表示位移量时，要求加后缀“L”。“起始点”表示从何处开始计算位移量，规定的起始点有三种：文件首，当前位置和文件尾。! a6 F+ [2 V1 C! S! J Z, m
其表示方法如表10.2。
9 ~+ o+ e, a: f- d6 @起始点 表示符号 数字表示; V. s5 G A# X5 \0 R9 v6 W
──────────────────────────
# p% ?8 {" g' F5 D文件首 SEEK—SET 0' C! b2 s5 z. _; n9 | l
当前位置 SEEK—CUR 1
8 T- Q0 y# f) o; _/ e- U# J文件末尾 SEEK—END 2; U* R, A, [, K
例如：7 D; r( [- R" R! K, N
fseek(fp,100L,0);其意义是把位置指针移到离文件首100个字节处。还要说明的是fseek函数一般用于二进制文件。在文本文件中由于要进行转换，故往往计算的位置会出现错误。文件的随机读写在移动位置指针之后， 即可用前面介绍的任一种读写函数进行读写。由于一般是读写一个数据据块，因此常用fread和fwrite函数。下面用例题来说明文件的随机读写。
7 n- R- d/ Z; W0 c2 k M! r+ m) r8 I* q5 W2 N
<FONT color=#ff00ff><B>[例10.8]</B></FONT>在学生文件stu list中读出第二个学生的数据。7 f" x' {; o, u8 Y
<FONT color=#009900>#include<stdio.h>7 Q! J, s6 e4 y4 z: V1 n+ M
struct stu, u9 Q3 B. k, x0 j: G3 b) ~
{7 m" [1 z c4 h. ?0 X$ ~. Q
char name[10];
' I9 @6 }$ ]: g3 b/ Pint num;2 _% C2 ~ J3 `6 N$ y2 {7 |8 R
int age;
/ q/ i# F: X4 i4 G) ochar addr[15];4 X3 f7 P3 t0 U; W+ p& E! k3 Z
}boy,*qq;
/ [9 A2 t) J* K/ imain()
* j8 N6 y% y! J, f9 E4 k+ Y& j{) h- K0 v6 s* _& p5 U
FILE *fp;
. r" [1 }0 u6 {: }& l! m0 ^) rchar ch;$ _" T7 _# e& i8 Q% v! N' i
int i=1;
2 ]. Z. X9 W* V3 t, yqq=&boy;
9 e+ S; s7 y6 s' h5 ~if((fp=fopen("stu_list","rb"))==NULL)
: \& h( h, p0 g. ?9 n{& ^8 s: X# g7 [$ {" C
printf("Cannot open file strike any key exit!");8 t4 i+ g. i, G( v' H: v
getch();
- X8 z `) t0 l8 V: Wexit(1);
& g/ x6 e; r+ N1 K+ ~4 n, r}
; p1 E; J9 J! m) N* g; lrewind(fp);
: {7 N) p9 Z! B' H1 kfseek(fp,i*sizeof(struct stu),0);; q: [3 G! e7 h
fread(qq,sizeof(struct stu),1,fp);6 {8 M/ Y0 g* p
printf("\n\nname\tnumber age addr\n");8 S9 y E4 e7 a5 b! `
printf("%s\t%5d %7d %s\n",qq->name,qq->num,qq->age,0 f7 F/ ?- L0 n* A) U6 \9 h
qq->addr);+ P3 x" ~$ n% H7 a7 b
}</FONT>% x3 B0 C" I0 G @
文件stu_list已由例10.6的程序建立，本程序用随机读出的方法读出第二个学生的数据。程序中定义boy为stu类型变量，qq为指向boy的指针。以读二进制文件方式打开文件，程序第22行移动文件位置指针。其中的i值为1，表示从文件头开始，移动一个stu类型的长度， 然后再读出的数据即为第二个学生的数据。0 ^* T9 Q$ H' U# Z# A; j
( E$ q% i' G: q
<FONT color=#ff0000>文件检测函数</FONT>
% k! k5 ^, C$ }) {2 E/ i @. T; y; _* Y+ i4 {' c
Ｃ语言中常用的文件检测函数有以下几个。
; @# e7 Y6 E* S, E+ @6 f" `: }一、文件结束检测函数feof函数调用格式： feof(文件指针)； - g1 x! [0 ?4 c0 U
功能：判断文件是否处于文件结束位置，如文件结束，则返回值为1，否则为0。" m( D2 M, F7 O5 a
7 Y3 H. r& e& n( d/ J9 P! |
二、读写文件出错检测函数ferror函数调用格式： ferror(文件指针)； 9 D! t8 s% t! r* H1 y
功能：检查文件在用各种输入输出函数进行读写时是否出错。 如ferror返回值为0表示未出错，否则表示有错。
' I) a% n& t* r! U$ K k q& m7 ?! e5 I* H# s, [
三、文件出错标志和文件结束标志置0函数clearerr函数调用格式： clearerr(文件指针);
P5 `$ [6 s) b5 E. p8 o功能：本函数用于清除出错标志和文件结束标志，使它们为0值。
0 x# C6 z: P/ [! y1 q0 l6 p' p( q/ u! S- V
<FONT color=#ff0000>Ｃ库文件</FONT>
/ m& H! Q; E$ i) i+ ^1 ?
& d* O0 W) j' DＣ系统提供了丰富的系统文件，称为库文件，C的库文件分为两类，一类是扩展名为".h"的文件，称为头文件， 在前面的包含命令中我们已多次使用过。在".h"文件中包含了常量定义、 类型定义、宏定义、函数原型以及各种编译选择设置等信息。另一类是函数库，包括了各种函数的目标代码，供用户在程序中调用。 通常在程序中调用一个库函数时，要在调用之前包含该函数原型所在的".h" 文件。
$ u: r! M1 j+ f3 ~ f! W" [在附录中给出了全部库函数。/ h! P# P5 }6 m* e( H3 p, w4 U
ALLOC.H 说明内存管理函数(分配、释放等)。8 w I! B* I- J) \4 L1 c
ASSERT.H 定义 assert调试宏。; c, i5 [0 t# E& E, L
BIOS.H 说明调用IBM—PC ROM BIOS子程序的各个函数。& k" Y- O3 B3 ]& k
CONIO.H 说明调用DOS控制台I/O子程序的各个函数。
5 U+ O/ F& D- ~: _8 DCTYPE.H 包含有关字符分类及转换的名类信息(如 isalpha和toascii等)。, |: M; z# `# \
DIR.H 包含有关目录和路径的结构、宏定义和函数。& k8 J1 Z9 W8 M+ ~) K& o
DOS.H 定义和说明MSDOS和8086调用的一些常量和函数。
" i2 M! c1 u7 P7 JERRON.H 定义错误代码的助记符。
* W3 i8 x" a& v* k, j/ N: eFCNTL.H 定义在与open库子程序连接时的符号常量。: J1 m& o4 U8 A, m; n( F5 q* \ n& n
FLOAT.H 包含有关浮点运算的一些参数和函数。
! ^0 M' Y* F# w8 \( tGRAPHICS.H 说明有关图形功能的各个函数，图形错误代码的常量定义，正对不同驱动程序的各种颜色值，及函数用到的一些特殊结构。$ D5 g, e6 k1 B: m* u! r
IO.H 包含低级I/O子程序的结构和说明。
; l+ q2 T9 x9 t$ iLIMIT.H 包含各环境参数、编译时间限制、数的范围等信息。! H7 |, i7 k- t W" z
MATH.H 说明数学运算函数，还定了 HUGE VAL 宏， 说明了matherr和matherr子程序用到的特殊结构。
" J( r- c j8 t+ k, A9 uMEM.H 说明一些内存操作函数(其中大多数也在STRING.H 中说明)。
* E2 q+ q& p4 V) d! s9 j7 K9 NPROCESS.H 说明进程管理的各个函数，spawn…和EXEC …函数的结构说明。+ i9 P( U0 j" g* m$ |
SETJMP.H 定义longjmp和setjmp函数用到的jmp buf类型， 说明这两个函数。
% v; d" _4 Z% V5 cSHARE.H 定义文件共享函数的参数。
. F5 U' I( U( ~# MSIGNAL.H 定义SIG[ZZ(Z] [ZZ)]IGN和SIG[ZZ(Z] [ZZ)]DFL常量，说明rajse和signal两个函数。
: D/ G; O7 Q7 Y# r0 tSTDARG.H 定义读函数参数表的宏。(如vprintf,vscarf函数)。/ ~7 ] [2 d& n# a
STDDEF.H 定义一些公共数据类型和宏。
$ J7 h0 Y4 Z( F4 ISTDIO.H 定义Kernighan和Ritchie在Unix System V 中定义的标准和扩展的类型和宏。还定义标准I/O 预定义流：stdin,stdout和stderr，说明 I/O流子程序。
. J7 j7 u3 y3 s/ T9 n, r6 FSTDLIB.H 说明一些常用的子程序：转换子程序、搜索/ 排序子程序等。1 f8 h; ?6 _: u! u1 m, ~
STRING.H 说明一些串操作和内存操作函数。3 \/ O. @9 C# f8 J* o7 b+ S2 D
SYS\STAT.H 定义在打开和创建文件时用到的一些符号常量。
( l% e( F/ G% }- K8 aSYS\TYPES.H 说明ftime函数和timeb结构。0 @, P. z& c! ^( ?
SYS\TIME.H 定义时间的类型time[ZZ(Z] [ZZ)]t。8 f( F! Y% {1 f0 Q; k
TIME.H 定义时间转换子程序asctime、localtime和gmtime的结构，ctime、 difftime、 gmtime、 localtime和stime用到的类型，并提供这些函数的原型。
1 T& D0 f7 ~1 e* F2 e+ PVALUE.H 定义一些重要常量， 包括依赖于机器硬件的和为与Unix System V相兼容而说明的一些常量，包括浮点和双精度值的范围。
) J' a$ }! o9 I& l
4 u) C; [$ n: e% y* m0 a<FONT color=#cc0000><B>本章小结</B></FONT>- X# E4 g3 O F$ J
7 V4 z" M9 N* X9 O1. Ｃ系统把文件当作一个“流”，按字节进行处理。
1 }: U' Q2 E# }3 K2 b; k, Q2 q8 A/ D2 [
2. Ｃ文件按编码方式分为二进制文件和ASCII文件。: m- B, J$ s/ j: f9 c6 |
4 C4 X9 t6 I7 T/ ?" M2 n2 i. Q2 \3. Ｃ语言中，用文件指针标识文件，当一个文件被 打开时， 可取得该文件指针。
( \" \2 }( P. _8 o( `& }
) |% x$ I3 h# ~$ S$ Z4 o2 v* g% C$ H$ l4. 文件在读写之前必须打开，读写结束必须关闭。
4 \0 G8 d9 M0 ^: L4 [1 w6 A/ R* x, H) s$ F% @' H
5. 文件可按只读、只写、读写、追加四种操作方式打开，同时还必须指定文件的类型是二进制文件还是文本文件。
8 ^& v7 A2 K! z$ T6 X9 s1 g5 |4 H4 E( |, K. m
6. 文件可按字节，字符串，数据块为单位读写，文件也可按指定的格式进行读写。+ M- n( I7 z6 E. N, `% Y0 z
0 [( R5 |1 f! j- b
7. 文件内部的位置指针可指示当前的读写位置，移动该指针可以对文件实现随机读写。</P> |
|
IP卡
狗仔卡
发表于 2004-10-4 02:22
转播
淘帖
分享
收藏
支持
反对
微信
提升卡
置顶卡
沉默卡
喧嚣卡
变色卡
抢沙发
显身卡
