C 语言把文件看作是一个字符（字节）的序列，即由一个一个字符（字节）的数据顺序组成。根据数据的组织形式，可分为 ASCⅡ 文件和二进制文件。文件的操作包括：文件的打开、文件的关闭、文件的读写操作、文件状态检查以及文件的定位等。

1 文件的打开1.1 函数原型
2 C, K6 k  d3 q4 `' A. \  AFILE *fopen(char *pname,char *mode)
/ z/ f% x8 E; K. _: |% e1.2 功能说明

按照 mode 规定的方式，打开由 pname指定的文件。若找不到由 pname 指定的相应文件，就按以下方式之一处理：

• 此时如 mode 规定按写方式打开文件，就按由pname 指定的名字建立一个新文件；
• 此时如 mode 规定按读方式打开文件，就会产生一个错误；
  

打开文件的作用：

• 分配给打开文件一个FILE 类型的文件结构体变量，并将有关信息填入文件结构体变量；
• 开辟一个缓冲区；
• 调用操作系统提供的打开文件或建立新文件功能，打开或建立指定文件；
  7 z& t( H! S0 A

FILE *：指出 fopen 是一个返回文件类型的指针函数；

1.3 参数说明

pname：是一个字符指针，它将指向要打开或建立的文件的文件名字符串。 mode：是一个指向文件处理方式字符串的字符指针。

1.4 返回值

正常返回：被打开文件的文件指针。
异常返回：NULL，表示打开操作不成功。

//定义一个名叫fp文件指针
FILE *fp；
//判断按读方式打开一个名叫test的文件是否失败
if((fp=fopen（"test"，"r"）) == NULL)//打开操作不成功
: E' C8 o4 U3 L8 L{
8 p6 g+ B  P, }$ Y& O; ^    printf("The file can not be opened.\n")；     
; d1 t7 G  _7 q1 B, R0 ^    exit(1);//结束程序的执行
% B) n3 j7 l' ^" v}

要说明的是：C 语言将计算机的输入输出设备都看作是文件。例如，键盘文件、屏幕文件等。ANSI C 标准规定，在执行程序时系统先自动打开键盘、屏幕、错误三个文件。这三个文件的文件指针分别是：标准输入 stdin、标准输出 stdout 和标准出错 stderr。

2 文件的关闭
/ r0 X. G  i) N2.1 函数原型
# B1 V8 i, v9 @9 j% aint fclose(FILE *fp)；
2.2 功能说明

关闭由 fp 指出的文件。此时调用操作系统提供的文件关闭功能，关闭由 fp->fd 指出的文件；释放由 fp 指出的文件类型结构体变量；返回操作结果，即 0 或 EOF。

2.3 参数说明

fp：一个已打开文件的文件指针。

2.4 返回值

正常返回：0。
异常返回：EOF，表示文件在关闭时发生错误。

int n=fclose(fp);
0 ]$ G4 {, M) t  s! }- i: ]+ {3 文件的读写操作
7 W; J/ l0 \/ N7 g6 \7 E6 x! B3.1 从文件中读取一个字符
3.1.1 函数原型
int fgetc(FILE *fp)；
: c9 }$ b: u( z  Y  d, K3.1.2 功能说明

从fp所指文件中读取一个字符。

3.1.3 参数说明

fp：这是个文件指针，它指出要从中读取字符的文件。

3.1.4返回值

正常返回： 返回读取字符的代码。
非正常返回：返回 EOF。例如，要从"写打开"文件中读取一个字符时，会发生错误而返回一个 EOF。

显示指定文件的内容:

//程序名为：display.c
1 H2 a" X8 K6 Z; X1 t. w6 h//执行时可用：display filename1 形式的命令行运行。显示文件filename1中的内容。例如，执行命令行display display.c将在屏幕上显示display的原代码。
1 x, l. y" C2 X0 v8 t2 B
* ^' C! H  t# m5 P//File display program.
#include <stdio.h>
void main(int argc,char *argv[]) //命令行参数
{
+ v2 }* B+ \4 ?7 g    int ch;//定义文件类型指针
    FILE *fp;//判断命令行是否正确
2 N' Y# H! N1 k2 c  m: x    if(argc!=2)
% N) j, l, B+ y6 t) Q: @    {
        printf("Error format,Usage: display filename1\n");
4 ~$ g! }" }1 [$ I( I7 [/ I' \" g6 a        return; //键入了错误的命令行，结束程序的执行
0 a/ r2 i# G0 W    }
    //按读方式打开由argv[1]指出的文件
    if((fp=fopen(argv[1],"r"))==NULL)
2 L1 A6 i5 i% J; d2 Y    {
        printf("The file <%s> can not be opened.\n",argv[1]);//打开操作不成功
. \# ^8 a2 {% G/ d, U, e3 I        return;//结束程序的执行
    }
    //成功打开了argv[1]所指文件
8 T& C9 X- k- w) y    ch=fgetc(fp); //从fp所指文件的当前指针位置读取一个字符
: Y. Q8 u" p! t- p* `  \! O& o    while(ch!=EOF) //判断刚读取的字符是否是文件结束符
    {
        putchar(ch); //若不是结束符，将它输出到屏幕上显示
/ @! O, X  p' r  t7 k# Z        ch=fgetc(fp); //继续从fp所指文件中读取下一个字符
    } //完成将fp所指文件的内容输出到屏幕上显示
: v1 v. l1 x# X    fclose(fp); //关闭fp所指文件
}
7 M9 X/ U: ]7 h3.2 写一个字符到文件中去
3.2.1 函数原型
int fputc(int ch,FILE *fp)
% g( `) G- T- }: U3 s: u' S' k, `3.2.2 功能说明

把 ch中的字符写入由 fp 指出的文件中去。

3.2.3 参数说明

ch：是一个整型变量，内存要写到文件中的字符（C 语言中整型量和字符量可以通用）。 fp：这是个文件指针，指出要在其中写入字符的文件。

3.2.4 返回值

正常返回： 要写入字符的代码。
非正常返回：返回 EOF。例如，要往"读打开"文件中写一个字符时，会发生错误而返回一个EOF。

将一个文件的内容复制到另一个文件中去:

//程序名为：copyfile.c
//执行时可用：copyfile filename1 filename2形式的命令行运行，将文件filename1中的内容复制到文件filename2中去。
//file copy program.
9 b0 e% {/ v6 D2 L' W; F$ `( J" w: l#include <stdio.h>
void main(int argc,char *argv[]) //命令行参数
{
; A9 ~' c0 g! K# N1 x+ E5 o; b    int ch;
; O7 t8 ]0 f" s+ J7 Z, X' P$ G    FILE *in,*out; //定义in和out两个文件类型指针
    if(argc!=3) //判断命令行是否正确
$ i* P4 u# n6 {/ A: l    {
5 w5 d7 B  G  D7 H. X        printf("Error in format,Usage: copyfile filename1 filename2\n");
        return; //命令行错，结束程序的执行
    }
5 A6 _9 x/ g4 v# n3 L$ k' r    //按读方式打开由argv[1]指出的文件
    if((in=fopen(argv[1],"r"))==NULL)
    {
        printf("The file <%s> can not be opened.\n",argv[1]);
1 \, a' O8 g% K: l! |- q$ d        return; //打开失败，结束程序的执行
    }
% `' r' [. B+ F, O- |- z    //成功打开了argv[1]所指文件，再
) @. h( v$ e* X; i4 W    //按写方式打开由argv[2]指出的文件
    if((out=fopen(argv[2],"w"))==NULL)
/ C$ ?! V  C# W8 q. _: U    {
. N6 x9 G6 c5 C( [6 p5 x        printf("The file %s can not be opened.\n",argv[2]);
        return; //打开失败，结束程序的执行
    }
8 h4 S7 g; z3 ~9 ?9 o    //成功打开了argv[2]所指文件
    ch=fgetc(in); //从in所指文件的当前指针位置读取一个字符
1 V- c& X2 u- v8 K- A  \8 W    while(ch!=EOF) //判断刚读取的字符是否是文件结束符
    {
2 d! ?6 r" C& c& [        fputc(ch,out); //若不是结束符，将它写入out所指文件
6 F$ x  \+ B* s& i& O; I! e        ch=fgetc(in); //继续从in所指文件中读取下一个字符
    } //完成将in所指文件的内容写入（复制）到out所指文件中
0 s+ a( B9 |" Q. R% `( v    fclose(in); //关闭in所指文件
    fclose(out); //关闭out所指文件
+ e2 O/ _- F# F- J1 X6 c/ O5 `: S. h) @2 {}

按十进制和字符显示文件代码，若遇不可示字符就用井号"#"字符代替之。

//程序名为：dumpf.c
//执行时可用：dumpf filename1 形式的命令行运行。
8 W8 l& A( M/ l; w9 Y! `- E// File dump program.
5 }  r  T8 _6 f7 ]#include <stdio.h>
, F9 d2 H8 [0 @, A* W# n8 K) rvoid main(int argc,char *argv[])
4 l, B  w0 B0 w& @{
- c: V. h; E9 R' B6 T  V    char str[9];
5 g- C" i4 r! A' W    int ch,count,i;
    FILE *fp;
- t; A1 |6 n) e& Q' j: {    if(argc!=2)
    {
        printf("Error format,Usage: dumpf filename\n");
        return;
    }
    if((fp=fopen(argv[1],"r"))==NULL)
' i+ \. j% X( p0 i/ k5 w. \# K    {
        printf("The file %s can not be opened.\n",argv[1]);
        return;
3 }7 e1 {9 K, \    }
    count=0;
0 @: S+ F1 _( k- O4 E: Y* R+ b    do{
        i=0;
0 F# `% L, z+ P2 E% h        //按八进制输出第一列，作为一行八个字节的首地址
        printf("%06o: ",count*8);
        do{
            // 从打开的文件中读取一个字符
$ p2 r! ~$ ]4 L9 U  M            ch=fgetc(fp);
  [8 d7 ]# R! g$ `. M0 J            // 按十进制方式输出这个字符的ASCII码
" z% d9 L' d5 K- D# d7 ~  y            printf("%4d",ch);
/ Z- V' F; `( a9 K7 J7 u            // 如果是不可示字符就用"#"字符代替
- c( V" z! G# ?* X  s6 A& H6 a1 ^1 R            if(ch<' '||ch>'~') str='#';
            // 如果是可示字符，就将它存入数组str以便形成字符串
            else str=ch;
            // 保证每一行输出八个字符
/ W* Q# m' K9 ^            if(++i==8) break;
        }while(ch!=EOF); // 遇到文件尾标志，结束读文件操作
        str='\0'; // 在数组str加字符串结束标志
        for(;i<8;i++) printf(" "); // 一行不足八个字符用空格填充
        printf(" %s\n",str); // 输出字符串
        count++; // 准备输出下一行
) H# l7 J/ q9 e  N    }while(ch!=EOF); // 直到文件结束
0 R, j0 A% g* w0 J    fclose(fp); // 关闭fp所指文件
}
3.3 从文件中读取一个字符串
3.3.1 函数原型
char *fgets(char *str,int n,FILE *fp)
3.3.2 功能说明

从由 fp 指出的文件中读取 n-1 个字符，并把它们存放到由 str 指出的字符数组中去，最后加上一个字符串结束符 '\0'。

3.3.3 参数说明

str：接收字符串的内存地址，可以是数组名，也可以是指针。
n： 指出要读取字符的个数。
fp：这是个文件指针，指出要从中读取字符的文件。

3.3.4 返回值

正常返回：返回字符串的内存首地址，即 str 的值。
0 w: N; Q, k& `非正常返回：返回一个 NULL 值，此时应当用 feof() 或 ferror() 函数来判别是读取到了文件尾，还是发生了错误。例如，要从"写打开"文件中读取字符串，将发生错误而返回一个 NULL 值。

3.4 写一个字符串到文件中去
3.4.1函数原型
1 o6 U: K9 v; G1 w# V4 M0 X/ X! zint fputs(char *str,FILE *fp)
( n* L8 T6 i# n7 `7 ~& f3.4.2 功能说明

把由 str 指出的字符串写入到 fp 所指的文件中去。

3.4.3 参数说明

str：指出要写到文件中去的字符串。

fp：这是个文件指针，指出字符串要写入其中的文件。

3.4.4 返回值

正常返回： 写入文件的字符个数，即字符串的长度。
2 }9 J& C! f8 E% s4 N  p非正常返回：返回一个 NULL 值，此时应当用 feof() 或 ferror( )函数来判别是读取到了文件尾，还是发生了错误。例如，要往一个"读打开" 文件中写字符串时，会发生错误而返回一个NULL值。

将一个文件的内容附加到另一个文件中去。

//程序名：linkfile.c
7 A1 d, E; D% H- v% |8 e! `! X//执行时可用：linkfile filename1 filename2形式的命令行运行，将文件filename2的内容附加在文件filename1之后。
8 k3 q/ o0 h$ u: b$ w! ~3 I// file linked program.
#include <stdio.h>
#define SIZE 512
void main(int argc,char *argv[])
{
# ^2 C- m" E9 G6 T0 L; H* N    char buffer[SIZE];
    FILE *fp1,*fp2;
; f) j% N; C4 L( U6 H2 }7 _' L* P    if(argc!=3)
& r' Z7 |2 j& q7 N9 |% F" |  H    {
$ X6 a9 G- A$ A  J6 T        printf("Usage: linkfile filename1 filename2\n");
; s( R' T8 {5 p. \$ }        return;
' |2 K% d0 u" T. p& L1 t: A5 c! P    }
; z1 l, M* |" y8 H" f# \    // 按追加方式打开argv[1] 所指文件
    if((fp1=fopen(argv[1],"a"))==NULL)
+ U* z/ S7 y, r, x/ e4 X    {
        printf("The file %s can not be opened.\n",argv[1]);
        return;
3 g/ t0 q& R+ M" ^3 i7 h    }
9 p/ C) `& M5 h( @7 B    if((fp2=fopen(argv[2],"r"))==NULL)
& W% b1 m, g* z    {
        printf("The file %s can not be opened.\n",argv[2]);
        return;
    }
# L, O" {2 }4 K& g/ o    // 读入一行立即写出，直到文件结束
+ |  L/ o9 @7 b0 c6 h3 ]1 B% k    while(fgets(buffer,SIZE,fp1)!=NULL)
        printf("%s\n",buffer);
4 i0 _& q) q- }4 @    while(fgets(buffer,SIZE,fp2)!=NULL)
        fputs(buffer,fp1);
( ]7 i3 i* [/ X) I. L    fclose(fp1);
% @) u# M4 z: Z/ d% @# v1 W6 T/ {    fclose(fp2);
4 r4 c- Q. N1 a/ R! z    if((fp1=fopen(argv[1],"r"))==NULL)
/ `" J" |4 X1 K- H    {
        printf("The file %s can not be opened.\n",argv[1]);
        return;
; ?! ?3 e- P. h% v' f0 g    }
    while(fgets(buffer,SIZE,fp1)!=NULL)
        printf("%s\n",buffer);
    fclose(fp1);
, \" i; D( G. o3 M4 R& v}
+ K0 c& i( R( T3 H/ W3.5 往文件中写格式化数据
3.5.1 函数原型
int fprintf(FILE *fp,char *format,arg_list)
& K: i- B3 O" c" `3 \* W3.5.2 功能说明

将变量表列（arg_list）中的数据，按照 format 指出的格式，写入由 fp 指定的文件。fprintf() 函数与 printf() 函数的功能相同，只是 printf() 函数是将数据写入屏幕文件（stdout）。

3.5.3 参数说明

fp：这是个文件指针，指出要将数据写入的文件。
5 d& L" `5 y) T/ X: ^* h. tformat：这是个指向字符串的字符指针，字符串中含有要写出数据的格式，所以该字符串成为格式串。格式串描述的规则与 printf() 函数中的格式串相同。
arg_list：是要写入文件的变量表列，各变量之间用逗号分隔。

//存储文件名：save.txt
# @- g3 m. w2 n* N//程序代码如下：
// file display program.
#include <stdio.h>
void main()
{
    char name[10];
    int nAge,nClass;
$ S$ l# f' \$ b' U  ?1 U, R    long number;
    FILE *fp;
$ |- H% b+ L. E: [    if((fp=fopen("student.txt","w"))==NULL)
    {
' _6 g1 j, }! u0 W" J* s        printf("The file %s can not be opened.\n","student.txt");
& B& s/ \- }, c! p) t) G; E0 p- E5 b        return;
    }
5 ?9 y8 m* @" l    fscanf(stdin,"%s %d %d %ld",name,&nClass,&nAge,&number);
; Q& O- P( U% t" \( ~4 W4 \    fprintf(fp,"%s %5d %4d %8ld",name,nClass,nAge,number);
0 j+ ~+ ~3 r% w6 ^& c5 W- J    fclose(fp);
    if((fp=fopen("student.txt","r"))==NULL)
$ _* o7 v# S- `" B+ d0 C    {
* f+ B: g* G# N0 h: t        printf("The file %s can not be opened.\n","student.txt");
        return;
    }
8 c$ e. n6 W0 T; X; B0 m    fscanf(fp,"%s %d %d %ld",name,&nClass,&nAge,&number);
2 k  u0 \3 X" n. u; t' k% ^    printf("name nClass nAge number\n");
    fprintf(stdout,"%-10s%-8d%-6d%-8ld\n",name,nClass,nAge,number);
    fclose(fp);
9 G7 w: m/ y/ V' M( p$ Y}
3.6 以二进制形式读取文件中的数据
3.6.1 函数原型
, K; h$ t8 i, O- q1 ?int fread(void *buffer,unsigned sife,unsigned count,FILE *fp)
4 j' r9 B9 ^' w8 `) U" j" B% [3.6.2 功能说明

从由 fp 指定的文件中，按二进制形式将 sife*count 个数据读到由 buffer 指出的数据区中。

3.6.3 参数说明

buffer：这是一个 void 型指针，指出要将读入数据存放在其中的存储区首地址。 sife：指出一个数据块的字节数，即一个数据块的大小尺寸。
count：指出一次读入多少个数据块（sife）。
fp：这是个文件指针，指出要从其中读出数据的文件。

3.6.4 返回值

正常返回：实际读取数据块的个数，即 count。
3 T* K( B, [1 E# z- W/ P异常返回：如果文件中剩下的数据块个数少于参数中 count 指出的个数，或者发生了错误，返回 0 值。此时可以用feof() 和 ferror() 来判定到底出现了什么情况。

3.7 以二进制形式写数据到文件中去
3.7.1 函数原型
* z$ _9 B1 _  |* nint fwrite(void *buffer,unsigned sife,unsigned count,FILE *fp)
3.7.2 功能说明

按二进制形式，将由 buffer 指定的数据缓冲区内的 sife*count 个数据写入由 fp 指定的文件中去。

3.7.3 参数说明

buffer：这是一个 void型指针，指出要将其中数据输出到文件的缓冲区首地址。
2 B5 U  u# H) E* A; G7 nsife：指出一个数据块的字节数，即一个数据块的大小尺寸。
count：一次输出多少个数据块（sife）。
fp：这是个文件指针，指出要从其中读出数据的文件。

3.7.4 返回值

正常返回：实际输出数据块的个数，即 count。
异常返回：返回0值，表示输出结束或发生了错误。

#include <stdio.h>
#define SIZE 4
struct worker
7 z5 N% L! o; a, P{ int number;
+ i& B2 B! x2 Y    char name[20];
/ k- [. ]  T$ _) f' i. a" x2 e    int age;
/ H8 E; m1 I1 N) R2 j( g( Y};
( l8 p+ V" _- y- Yvoid main()
5 g6 |5 T. ]8 ?* P" r, g, Q6 O{
, `8 U  Q+ \1 `: S    struct worker wk;
    int n;
9 b7 F. `) l0 w0 w% F5 w: r    FILE *in,*out;
' x& |- w6 @( K+ s# E    if((in=fopen("file1.txt","rb"))==NULL)
, S; N2 o* t: o) g+ I    {
* Q( O1 q( W" }        printf("The file %s can not be opened.\n","file1.txt");
$ t( L( R8 M  p+ ]        return;
    }
: A; @3 x+ w( f) T    if((out=fopen("file2.txt","wb"))==NULL)
$ W; N3 ?" L$ z0 A/ [/ T  r    {
        printf("The file %s can not be opened.\n","file2.txt");
        return;
, R2 K+ o) i  W8 m+ g1 u% K  I    }
! M5 n* k) d" j7 q* V" A2 M  H    while(fread(&wk,sizeof(struct worker),1,in)==1)
: F; V& \6 R2 M6 {5 N3 i        fwrite(&wk,sizeof(struct worker),1,out);
; z  l* I  e+ j; u2 C    fclose(in);
3 [$ d  ]3 A  Z5 e+ n1 B    fclose(out);
7 l- f- Y& M0 A  E& M}
3.8 以二进制形式读取一个整数
/ d7 X% Y" \" r7 ^, v9 y- _3.8.1 函数原型
int getw(FILE *fp)
  Y5 u& S) E/ G4 X3.8.2 功能说明

从由 fp 指定的文件中，以二进制形式读取一个整数。

3.8.3 参数说明

fp：是文件指针。

3.8.4 返回值

正常返回：所读取整数的值。
8 s9 O" p( l0 Z9 Z* i9 j8 h异常返回：返回 EOF，即 -1。由于读取的整数值有可能是 -1，所以必须用 feof() 或 ferror() 来判断是到了文件结束，还是出现了一个出错。

#include <stdio.h>
) }0 Z. R' p/ P7 C1 J9 J. N6 m2 mvoid main(int argc,char *argv[])
1 N1 A1 z3 q! u, N* X{
0 e. S: ~( Q" ]& p( X' W4 u    int i,sum=0;
. I6 ~* X* J- e8 i3 ^1 |, ^    FILE *fp;
+ I% F- Q# C! v) g  K    if(argc!=2)
    {
        printf("Command error,Usage: readfile filename\n");
        exit(1);
    }
    if(!(fp=fopen(argv[1],"rb")))
    {
        printf("The file %s can not be opened.\n",argv[1]);
        exit(1);
( |' s$ u3 l* L    }
    for(i=1;i<=10;i++) sum+=getw(fp);
+ U* c/ Y9 ]; l: P8 ?: n    printf("The sum is %d\n",sum);
    fclose(fp);
- x! X5 R7 @) i4 M}
- N9 `4 Q/ ~. b; i5 P4 R5 h" [; D3.9 以二进制形式存贮一个整数
' s. }9 q1 w: U% ?# H8 U5 H3.9.1 函数原型
int putw(int n,FILE *fp)
2 T( @7 X3 I, v, [' ]. M& v/ H3.9.2 功能说明

以二进制形式把由变量 n 指出的整数值存放到由 fp 指定的文件中。

3.9.3 参数说明

n：要存入文件的整数。
fp：是文件指针。

3.9.4 返回值

正常返回：所输出的整数值。
( |- o5 ]; a  B8 e# b8 K  Z$ y异常返回：返回 EOF，即 -1。由于输出的整数值有可能是 -1，所以必须用 feof() 或 ferror() 来判断是到了文件结束，还是出现了一个出错。

#include <stdio.h>
void main(int argc,char *argv[])
- Y5 f* ?* q5 v8 ~. r2 T{
6 A8 A6 I( {( m$ H& v    int i;
# B0 V0 f0 q0 j4 k% C9 ?. I    FILE *fp;
/ P, \# u0 v4 P; Q! f+ u/ m    if(argc!=2)
    {
        printf("Command error,Usage: writefile filename\n");
        return;
    }
3 A6 r( |, T0 c1 Q; u
    if(!(fp=fopen(argv[1],"wb")))
    {
        printf("The file %s can not be opened.\n",argv[1]);
% t; q% T8 }1 H        return;
    }
    for(i=1;i<=10;i++) printf("%d\n", putw(i,fp));
' Y3 ?, u, s9 k& q, w* `1 V3 a$ i    fclose(fp);
2 g1 |' e* X+ v# {}
, L) C0 O3 K) O/ Q" x/ Y0 t- j4 文件状态检查
$ e  ~7 p, K" ^5 O1 D+ i- y4.1 文件结束
! S- M/ N% C) v3 {# p) x3 ]4.1.1 函数原型
int feof(FILE *fp)
4.1.2 功能说明

该函数用来判断文件是否结束。

4.1.3 参数说明

fp：文件指针。

4.1.4 返回值

0：假值，表示文件未结束。
1：真值，表示文件结束。

#include <stdio.h>
5 z  v( O! v5 ]1 ?$ @# [void main(int argc,char *argv[])
{
2 |* {6 j8 h6 q+ w8 z- ~, _" s    FILE *in,*out;
    char ch;
    if(argc!=3)
    {
        printf("Usage: copyfile filename1 filename2\n");
        return;
    }
# N+ ^4 |( u4 h3 g( r. R    if((in=fopen(argv[1],"rb"))==NULL)
, y  n! G2 ?! D/ H. w4 S    {
3 g5 N1 z$ e/ k% s2 e. i( ^        printf("The file %s can not be opened.\n",argv[1]);
        return;
    }
    if((out=fopen(argv[2],"wb"))==NULL)
    {
        printf("The file %s can not be opened.\n",argv[2]);
        return;
    }
2 m* I1 B) o* R+ H  M    while(!feof(in))
    {
- d2 W7 b8 [! B) u$ \        ch=fgetc(in);
        if(ferror(in))
, D& Z7 K% y" `9 W        {
            printf("read error!\n");
3 [9 m. c! L5 `+ d2 g- w$ V7 p            clearerr(in);
6 H9 v& R% R' _) n% h* b        }
& g& e3 f# F# `% |5 [        else
        {
            fputc(ch,out);
% T, o) ^) |) G4 V& M, m            if(ferror(out))
$ b! P! }1 d2 [. o6 {# e            {
                printf("write error!\n");
                clearerr(out);
            }
& x% \' H& @( M/ h1 f9 @7 x        }
5 O/ r* y, u) Q    }
: w5 s- S3 B; F. D& i$ \    fclose(in);
    fclose(out);
4 d! m% R& |7 l1 C6 ?- _7 ?; C}
4.2 文件读/写出错
4.2.1 函数原型
int ferror(FILE *fp)
4.2.2 功能说明

检查由 fp 指定的文件在读写时是否出错。

4.2.3 参数说明

fp：文件指针。

4.2.4 返回值

0：假值，表示无错误。
5 _% N" f$ @; v4 Q7 S% U1：真值，表示出错。

4.3 清除文件错误标志
  z* p+ A% y* O7 V8 S, u4.3.1 函数原型
" T  c2 J1 _  X. Z% R2 \void clearerr(FILE *fp)
, w2 W8 T+ _) m$ k- t+ E( W) K4.3.2 功能说明

清除由 fp 指定文件的错误标志。

4.3.3 参数说明

fp：文件指针。

4.3.4 返回值

无。

#include <stdio.h>
$ O0 G. k1 n. q2 H" O4 `) cvoid main(int argc,char *argv[])
6 g6 k5 D/ r6 u# ~{
    FILE *in,*out;
8 \" |. `  @. w( U6 I. _8 T    char ch;
    if(argc!=3)
    {
! C! f/ n5 d$ c& v: K        printf("Usage: copyfile filename1 filename2\n");
        return;
    }
/ S3 j( h( ]0 l# W" @) U; z3 i    if((in=fopen(argv[1],"rb"))==NULL)
( h& z- @1 z% N. `, [7 t/ S8 A    {
        printf("The file %s can not be opened.\n",argv[1]);
0 {4 {0 ~8 L7 L& T0 I9 a* ?9 [, i; D7 W        return;
- m0 t- P6 b; n8 C    }
    if((out=fopen(argv[2],"wb"))==NULL)
    {
        printf("The file %s can not be opened.\n",argv[2]);
        return;
    }
4 Z. y- R0 P* a7 e9 _    while(!feof(in))
    {
/ I  v/ c5 H: d! p+ Q( {; l0 J( Y        ch=fgetc(in);
" O2 w7 ^5 e) y! p+ z! a        if(ferror(in))
5 b" {& j( x3 a8 {        {
/ X+ W5 P- X$ |8 ~( N            printf("read error!\n");
8 \- n* Y; F$ ?: R. l7 |- v            clearerr(in);
) x) H0 N$ ?# O1 j4 [9 z7 G        }
/ {9 c- q+ [8 m        else
        {
            fputc(ch,out);
            if(ferror(out))
            {
                printf("write error!\n");
                clearerr(out);
            }
( P6 ]$ E( s! q3 k9 b        }
    }
; P+ \0 r# w- z. [  k1 j) \    fclose(in);
    fclose(out);
}
: {% ^6 ^$ K. o0 Q2 |. w( U8 j. b& s4.4 了解文件指针的当前位置
& L1 Z/ p4 s3 b* l5 g! b: Y4.4.1 函数原型
long ftell(FILE *fp)
# g( z* g0 e- {) a& p  F& k, D  m4.4.2 功能说明

取得由 fp 指定文件的当前读/写位置，该位置值用相对于文件开头的位移量来表示。

4.4.3参数说明

fp：文件指针。

4.4.4 返回值

正常返回：位移量（这是个长整数）。
8 N8 t* p3 v, Y- F; L* C+ ?异常返回：-1，表示出错。

5 文件定位
1 A  z6 c* p- }# @7 a5 {: y: ?/ e5.1 反绕
' a* t' U" w2 [9 \- I: p& s5.1.1 函数原型
3 C3 y( R" D) w3 e- V5 i. Qvoid rewind(FILE *fp)
5.1.2 功能说明

使由文件指针 fp 指定的文件的位置指针重新指向文件的开头位置。

5.1.3 参数说明

fp：文件指针。

5.1.4返回值

无。

#include <stdio.h>
3 X. F5 c! o+ U( p" ]) rvoid main()
{
4 m7 [  S6 \% v4 s    FILE *in,*out;
    in=fopen("filename1","r");
: o) t+ M; a4 [    out=fopen("filename2","w");
    while(!feof(in)) fputc(fgetc(in),out);
' f! K6 b6 N  H6 b5 r" G5 N    rewind(out);
    while(!feof(in)) putchar(fgetc(in));
    fclose(in);
    fclose(out);
& x, W- J+ o1 G! x, ?}
5.2 随机定位
5.2.1 函数原型
int fseek(FILE *fp,long offset,int base)
9 g, X! C9 v3 a4 b2 U5.2.2 功能说明

使文件指针 fp 移到基于 base 的相对位置 offset 处。

5.2.3 参数说明

fp：文件指针。
offset：相对 base 的字节位移量。这是个长整数，用以支持大于 64KB 的文件。
base：文件位置指针移动的基准位置，是计算文件位置指针位移的基点。ANSI C 定义了 base 的可能取值，以及这些取值的符号常量。

5.2.4 返回值

正常返回：当前指针位置。
7 R- N6 s0 o9 e# o" b  c+ |异常返回：-1，表示定位操作出错。

#include <stdio.h>
#include <string.h>
* @. h8 d' w5 ^, H) Ustruct std_type
{
    int num;
. W8 s% Z0 i& D5 K5 z- A) Z    char name[20];
! F- D5 `# y# R7 Z1 Q+ T8 ~    int age;
    char class;
- h9 ?* S8 Y# ^7 C9 o6 e}stud;
# b: p4 G5 E/ ^- X' p1 B$ E; Vint cstufile()
{
  f+ J$ q& o% R( B    int i;
8 T0 y2 \! C$ l+ R    FILE *fp;
    if((fp=fopen("stufile","wb"))==NULL)
5 K" f' ]" }; h/ K. d' a- e& F    {
/ Y5 a+ e+ G+ N' Q+ C+ ^, h7 @        printf("The file can't be opened for write.\n");
. m( g1 G' a' ~* g- f        return 0;
    }
% ~) R: j3 }" R+ e* s' A' ^* x3 m    for(i=1;i<=100;i++)
    {
        stud.num=i;
; {, ?' F6 e0 T7 T        strcpy(stud.name,"aaaa");
        stud.age=17;
        stud.class='8';
        fwrite(&stud,sizeof(struct std_type),1,fp);
; x& U, m) e+ H2 |$ l, u8 g4 G) u    }
    fclose(fp);
' l# n! J+ Q8 A# T/ J    return 1;
}
void main()
9 u' X6 L) l. p+ ~{
    int n;
4 X2 m% b4 w: @# x    FILE *fp;
' o& Q: K6 y, r" C9 e  B, b    if(cstufile()==0) return;
8 x4 f% J& B4 K* Q& s1 f    if((fp=fopen("stufile","rb"))==NULL)
    {
        printf("The file can not be opened.\n");
" v3 v  N" O+ Z' x        return;
, x. H! d) U' q1 b    }
; N+ {% c& _! F; P) `7 z7 u    for(n=0;n<100;n+=2)
    {
        fseek(fp,n*sizeof(struct std_type),SEEK_SET);
        fread(&stud,sizeof(struct std_type),1,fp);
        printf("%10d%20s%10d%4c\n",stud.num,stud.name,stud.age,stud.class);
0 {) U" X; P5 e+ [& O3 V6 S* `    }
    fclose(fp);
}
6 Y! B/ y+ f/ `, D5.3 关于exit()函数
5.3.1 函数原型
7 h4 v9 M3 @7 E# c2 j. i, Zvoid exit(int status)
5.3.2 功能说明

exit() 函数使程序立即终止执行，同时将缓冲区中剩余的数据输出并关闭所有已经打开的文件。

5.3.3 参数说明

status：为 0 值表示程序正常终止，为非 0 值表示一个定义错误。

5.3.4 返回值

无。

5.4 关于feof()函数
0 ~' j, y. H* y" {: |5.4.1 函数原型
int feof(FILE *fp)
5.4.2 功能说明

在文本文件（ASCII 文件）中可以用值为 -1 的符号常量 EOF 来作为文件的结束符。但是在二进制文件中 -1 往往可能是一个有意义的数据，因此不能用它 来作为文件的结束标志。为了能有效判别文件是否结束，ANSI C 提供了标准函数 feof()，用来识别文件是否结束。

5.4.3 参数说明

fp：文件指针。

5.4.4 返回值

返回为非 0 值：已到文件尾。
返回为 0 值：表示还未到文件尾。

* F9 A* }! l0 m8 B' @1 @/ h