Unix下C语言----标准文件编程

  在Unix的应用中，读写文件是最常见的任务。诸如报表的生成，日志的记录，批交易报文的传送都采用文件实现。标准文件编程就是操作文件最简单的huguidong11@yahoo.cn 工具。

 

1：文件的创建、打开、关闭与删除

   在标准库中，结构FILE是指向文件的指针，所有对文件的操作都是通过FILE完成的，FILE指针也称为文件流，它定义在头文件<stdio.h>，相对于整形的低级文件I/O描述符，它提供了I/O缓冲功能。

1)创建、打开、关闭与删除文件的函数族

标准文件编程库中用于文件创建、打开、关闭与删除的函数如下：

#include<stdio.h> FILE *fopen(const char *filename,const char *type); FILE *freopen(const char *filename,const char *type,FIlE *strem); int fclose(FILE * stream); int remove(const char *filename); int rename(const char *oldname,const char *newname); /*filename 打开文件的名称(带路径)*/ /*Type 打开文件的方式，由权限和类型两部分组成，前者可以是r、w、a、r+、w+、a+，后者默认表示文本文件、使用b表示二进制文件*/ /*stream 已经打开的文件指针*/

函数fopen打开或创建文件；fclose关闭文件；函数freopen重新打开文件；函数remove删除磁盘文件；函数rename更改文件名称。

ex1:以只读方式打开文本文件/etc/passwd:

FILE *fp;

fp=fopen("/etc/passwd","r");

ex2:以二进制方式创建文件rr.txt：

FILE *fp;

fp=fopen("rr.txt","wb");

 

2)freopen函数

  本函数实现文件流的替换。它首先关闭原文件流stream，然后再以freopen的方式打开一个新的文件流，此后对原文件流的任意操作都自动转换为对新文件流的操作。成功时返回指向新文件的FILE型指针，否则返回NULL。

  Unix进程默认打开三个文件：标准输出、标准输入、标准错误输出，它们的FILE标识符号分别是stdout、stdin、stderr。函数freopen常用于将以上三个文件流重定向，实现方法如下：

 

/*-----------open.c------------*/ #include<stdio.h> void main() { FILE *fp; char *szBuf[100]; /*将屏幕标准输出的内容重定向到文件"/tmp/1" */ if((fp=freopen("/tmp/1","w",stderr))==NULL) { printf("stderr--/tmp/1 failed./n"); return ; } /*stderr已经输出重定向，所有错误输出内容都将写到"/tmp/1"*/ fputs("T Like Unix./n",stderr); /*关闭文件*/ fclose(fp); /*将标准输入由键盘输入更改为从文件"/tmp/1"中读入*/ if((fp=freopen("/tmp/1","r",stdin))==NULL) { printf("stdin --/tmp/1 failed./n"); return ; } memset(szBuf,0,sizeof(szBuf)); /*stdin 已经输入重定向，所有内容都将写入文件"/tmp/1"*/ fgets(szBuf,sizeof(szBuf),stdin); printf("szBuf=[%s]",szBuf); fclose(fp); }

 

3)fclose函数

   为了减少系统资源消耗、避免误改文件内容和更新文件缓冲，应该及时关闭在将来一段时间内不需要使用的文件。函数fclose关闭文件流stream，成功时返回0，否则返回EOF；

4)remove

   函数remove删除字符串filename指定的文件或目录，当filename指定文件时，remove相当于unlinke函数，当filename指定目录时，相当于rmdir;

 

 

 

 1)字符读写

    字符读写函数每次只操作一个字符，为了提高磁盘读写效率，标准文件编程中提供了缓冲处理。

    (1)字符输入函数

     #include<stdio.h> int getc(FILE *stream); int getchar(void); int fgetc(FILE *stream);

     函数getc以unsigned char类型读取文件输入流stream中的一个字符，并将该无符号字符转化为整数返回，同时移动文件指针到下一个字符处。函数getchar实际上是关于getc的一个宏定义"getc(stdin)".

     函数fgetc的功能类似于getc，不同的是，它的执行速度远低于getc，因此getc常常被定义在宏中使用。

     当文件结束或错误时，这三个函数都将返回EOF，EOF为常数，因此正确的文件结束判断代码如下：

     int c;/*---char c是错误的---*/ ..... c=getc(FILENAME); if(c==EOF) ....

     (2)字符输出函数族

       #include<stdio.h> int putc(int c,FILE *stream); int putchar(int c); int fputc(int c,FILE *stream);

       函数putc首先先将int型参数c自动转换为unsigned char类型，然后写入文件流stream中，同时移动文件指针到下一个字符处。函数putchar 实际上是关于putc的宏定义"putc(stdout)"。

      (3)实例

      报文解析是Unix应用的一个重要内容。双方把约定的几个域通过某种排序和分割方式组合在一起，就成了报文。报文解析就是从报文中分解出各个域的数据，比如从银行的代收代付报文查找出账号域和资金域的内容。

      字符串报文是报文的重要分支，它以字符串为载体记录了域的数据。在字符串报文中，域与域之间最常见的2中分隔方式是固定长度分割和特殊字符(串)分割。前者每个域占用固定宽度，解析时只是读取特定位置的数据即可。后者的域与域之间由固定的字符(串)连接，解析时需要计算固定字符(串)出现的次数，以决定域的序号和内容。Unix中passwd文件就是由":"分割的字符串报文组合而成的。

     例子：一个使用字符读写函数解析报文的，程序读取文件的"/etc/passwd"中每一个字符，并将"用户名称"域(报文的第一个域)单独提出，存入文件"copyname.txt"中，源程序如下：

     #include<stdio.h> void main() { FILE *fpr,*fpw; int c=0,f=0; /*以下打开源文件*/ if((fpr=fopen("/etc/passwd","r"))==NULL) { printf("open file /etc/passwd failed./n"); return ; } /*以下打开目标文件*/ if((fpw=fopen("./copyname.txt","w"))==NULL) { printf("open file ./copyname.txt failed./n"); fclose(fpr);/*如果程序需要同时打开两个或两个以上文件，当后一个文件的打开操作发生错误，而不得不退出函数时，务必关闭前面已经打开的文件。*/ return ; } while((c=getc(fpr)!=EOF)) { /*字符已经读取到了c中*/ if(f==0) { if(c!=':') putchar(putc(c,fpw)); else f=1; } else if(c=='/n') { f=0; putchar(getc(c,fpw)); } } fclose(fpr); fclose(fpw); }

    

 2)按行读写

   标准函数编程库提供了行读写函数，该类函数读取一行以换行符"/n"结束的数据，写入数据时自动输出换行符。

   (1)行输入函数族

       #include<stdio.h> char *gets(char *s); char *fgets(char *s,int n,FILE *stream);

       函数gets从标准输入流(stdin)中读取一串字符存储到参数s所指向的内存空间中，文件结束或者错误发生时返回NULL，否则将返回参数s所指向的内存地址。

       函数fgets中键入了防溢出控制，它从文件流stream中读取一串字符到参数s所指向的内存空间，但读取数据的长度(包括换行符"/n")不能超过n-1,。参数n代表了字符串s的最大存储空间。倘若待读入的实际数据长度包括("/n")超过了n-1，函数将截取该n个字符返回，剩余的字符将在下一次fgets调用时读入。

       两个函数都把读取的字符信息存入字符串s中，并且自动增加字符串结束符"0",这也是fgets一次性最多只能读入n-1个字符的原因(第n个字符需要存储结束符"0")。函数调用成功时返回参数s的值，即指向输入的字符信息，否则返回空指针NULL。

      /*不利用fgets函数的返回值*/ char s[1024]; ... fgets(s,sizeof(s),STREAM); puts(s); ..... /*利用fgets函数的返回值*/ char s[1024]; ... puts(fgets(s,sizof(s),STREAM); ....

     (2)行输出函数

     标准文件编程库中用于文件行输出的函数如下：

     #include<stdio.h> int puts(const char *s); int fputs(const char *s,FILE *steam);

     参数s指向一串以字符串结束符"0"结尾的字符；函数puts把该字符串(不包括结束符"0")写入到标准输出流stdout中，并自动输出换行符"/n"；函数fputs字符串s(不包括结束符"0")写入文件流stream中，但不再输出换行符"/n"。

     两函数都不输出字符串末的结束符，输出失败时，都返EOF。

     (3)实例：

      解析报文文件的另一种方法是先读入一行数据，再通过字符串函数分解。本处设计了一个使用行读写解析报文的例子，程序按行读取文件"/etc/passwd"，并将"用户名称"域提取出来(报文的第一个域)单独提取出来，存入文件"copyname.txt"中，源程序如下：

   #include<memory.h> #include<string.h> #include<stdio.h> void main() { FILE *fpr, *fpw; char buf[1024], *p1,*p2; /*以下打开源文件*/ if((fpr=fopen("/etc/passwd","r"))=NULL) { printf("open file /etc/pwasswd failed. /n"); return ; } if((fpw=fopen("./copyname.txt"))==NULL) { printf("open file ./copyname.txt failed./n"); fclose(fpr); return ; } memset(buf,0,sizeof(buf)); while(fgets(buf,sizeof(buf),fpr)!=NULL) { /*p1指向第一个":",p2指向第二个":"*/ if((p1=strstr(buf,":"))==NULL)break; if((p2=strstr(p1+1,":"))==NULL)break; p1++;p2++; /*p1指向第二个域密码字段，p2指向第三个域用户ID字段*/ /*以下代码移动字符串内容，将ID字段的内容移动到用户名字段后*/ while(*p2!=':') { *p1=*p2; p1++;p2++; } *p1=0; /*屏幕输出*/ puts(buf); /*文件输出*/ fputs(buf,fpw); fputs("/n",fpw); memset(buf,0,sizeof(buf)); } fclose(fpr); fclose(fpw); }

 3)按块读写

    块读写函数，能够输入输出任何数量的字符，在操作二进制文件时常常使用，标准文件编程库中用于文件块输入输出的函数如下：

   #include<stdio.h> size_t fread(void *ptr,size_t size,size_t nitems,FILE *stream); size_t fwrite(const void *ptr,size_t size, size_t nitems,FILE *stream);

   函数fread从文件流stream中读入nitems个数据项存储到指针ptr所指向的内存中，每个数据项具有size字节大小，一次操作总共读入size*nitems个字节。

  函数fwrite将ptr的数据写入到stream中，每次可写入size*nitems个字符。参数nitems表示写入文件的数据项个数，参数size表示每个数据项具有的字节大小。

 注：在大多数Unix中，size_t被定义为无符号整形：

 typedef unsigned int size_t;

  fread&fwrite都不返回实际读写的字符个数，而返回的是实际读写的数据项数。成功时，返回值等于参数nitems值，否则返回值将小于nitems值。

  块I/O函数常应用于二进制文件读写中，操作比较灵活，既可以读写一个字符，也可以读写一个结构，还可以读写任意数据类型。/*读写字符*/ char c; .... fread(&c,sizeof(char),1,INSTREAM); ... fwrite(&c,sizeof(char),1,OUTSTREAM); /*读写结构*/ typedef struct { char c; int l; }MYSTRUCT; ... MYSTRUCT my; ... fread(&my,sizeof(MYSTRUCT),1,INSTREAM); ... fwrite(&my,sizeof(MYSTRUCT),1,OUTSTREAM); /*读写数组*/ double f[5]; ... fread(f,sizeof(double),5,INSTREAM); ... fwrite(f,sizeof(double),5,OUTSTREAM);

 

实例

     块读写函数经常操作二进制文件，保留内存信息或永久存储数据信息等。比如在软件中涉及一个文件型数据库，用以存取历史交易明细。

    本处设计了一个存取数据信息的实例，通过文件"array.dat"存储和读取一个整形数组，其中文件起始记录数组的长度，随后是数组的数据信息。源文件如下：

   /*数据信息存储 wdata.c*/ #include<stdio.h> void main() { FILE *fp; /*data array, readers can modify the lenght and the context of the array*/ int narray[5]={3132,2354,45,224,566}; int all=5; if((fp=fopen("array.dat","wb"))==NULL); { printf("open file array failed./n"); return ; } fwrite(&all,sizeof(int),1,fp); /*实际写入1*sizeof(int)=4个字符*/ fwrite(narray,sizeof(int),all,fp); /*实际写入all*sizeof(int)个字符*/ fclose(fp); } /*数组信息恢复rdata.c*/ include<stdio.h> void main() { FILE *fp; int narray[5]; int all=6,i; if((fp=fopen("array.dat","rb"))=NULL); { printf(open file array.dat failed./n); return ; } /*读取文件中存储的第一个整数，获取存储数组的元素数*/ fread(&all,sizeof(int),1,fp); /*读取文件存储的数组元素*/ fread(narray,sizeof(int),1,fp); printf("all=%d/n",all); for(i=0;i<all,i++) { printf("[%d]=%d",i,narray[i]); } printf("/n"); fclose(fp); }

 

---

 

 

 

 

3:函数的变长参数

 

  文件的格式化参数都支持变长参数。定义时，变长参数列表通过省略号"..."表示，因此，具有变长参数列表的函数定义格式如下：

  type 函数名(参数1,参数2,参数n,...);

其中type为函数的返回值类型，参数1~n为定长参数，...代表变长参数，...必须定义在参数的最右端。如下例：

  int printf(const char * format,...);

  int mysum(...);

 

1)变长参数的使用

  Unix的变长参数通过va_list对象实现，定义在文件"stdarg.h"中，变长参数的应用模板代码如下：

 #include<stdarg.h> function(parmN,...) va_list pvar; ......... va_start(pvar,parmN); while() { ........ f=va_arg(pvar,type); ........ } va_end(pvar);

1 step. va_list pvar

申明va_list数据类型变量pvar，该变量访问变长参数列表中的参数

2 step. va_start(pvar,parmN)

宏va_start初始化变长参数列表。pvar是va_list型变量，在step1定义，记载列表中的参数信息。parmN是省略号"..."前的一个参数名，va_start根据此参数，判断参数列表的起始位置。

3 step: va_arg(pvar,type)

获取变长参数列表中参数的值。pvar是step定义的va_list型变量，type为参数值的类型，也是红va_arg返回数值的类型，如：

va_arg(pvar,int);

va_arg(pvar,float);

宏va_arg执行完毕后自动更改对象pvar，将其指向下一个参数。

4 step：va_end(pvar)

关闭本次对变长参数列表的访问。

设计函数mysum，计算输入参数的和并返回结果，源程序如下：

#include<stdarg.h> int mysum(int i,...) { int r=0,j=0; va_list pvar; va_start(pvar,i); for(j=0;j<i;++j) { r +=va_arg(pvar,int); } va_end(pvar); return(r); } void main() { printf("sum(1,4)=%d/n",mysum(1,4)); printf("sum(2,4,8)=%d/n",mysum(2,4,8)); }

 

compile & run

 

$make mysum

     cc -O -o mysum mysum.c

$./mysum

sum(1,4)=4;

sum(2,4,8)=12;

 

4)变长参数的传递

变长参数传递的函数族如下：

#include<stdarg.h> int vprintf(const char *format,va_list ap); int vfprintf(FILE *stream,const char *format,va_list ap); int vsprintf(char *str,const char *format,va_list ap);

这些函数完全等价于格式化函数，只是在形式上采用固定参数替代变长参数列表，这样描述的函数更加紧凑，这些函数长应用于变长参数内部的功能实现。

实现：设计函数"int PrintLog(FILE *stream,const  char *pformat,...)"，它按照字符串format的内容，控制后即参数的数量和格式，并在文件流stream中输出。源程序代码如下：

#include<stdio.h> #include<stdarg.h> int PrintLog(FILE *pfile,const char * pformat,...) { va_list _va_list; char szbuf[1024]; if(pformat==null || pfile==null)return -1;/*判断指针是否正确*/ va_start(_va_list,pformat);/*初始化变长参数列表*/ vsprintf(szbuf,pformat,_va_list);/*传递变长参数*/ va_end(_va_list); fputs(szbuf,pfile); return 0; } void main() { PrintLog(stderr,"[%s][%s][%d][%c]/n","This","is",5,'a'); }

 

 

 

---

 

4：文件读写位置的定位

  在实际应用中，我们常常只需要读取文件中的一小段内容，或者写入一小段呢日哦难怪到文件中，使用文件的读写定位功能可以避免些不必要的的数据段。例如某文件由一系列固定大小记录块组成，当访问其第n块记录时，可以先将文件指针移动到第n块记录的起始位置，再访问1个记录快大小的数据，并不需要从文件头开始读取n个记录块。

  标准文件变成库中用于定位文件读写为止的函数如下：

  #include<stdio.h> int fseek(FILE *stream,long int offset,int whence); void rewind(FILE *stream); long int ftell(FILE *stream);

其中fseek改变文件流stream中的访问位置，参数whence表示文件定位的方式，fseek中提供了三种定位方式，参数offset表明了定位的偏移量，其值可正可负，与whence一起确定访问文件的最终定位。

whence              含义                     文件定位于

SEEK_SET           从文件头开始定位   0+offset

SEEK_CUR          从当前位置开始定位  当前位置+offset

SEEK_END          从文件尾开始定位     文件末+offset

 

rewind重置流stream，将文件流定位于文件开始处，相当于执行了以下操作：

void fseek(stream,0L,SEEK_SET);

函数ftell获取文件流的当前位置，调用成功时将该值返回，否则返回-1。

注：

    大多数系统中，可以通过以下代码获取文件的长度(len)

    long len; fseek(stream,0,SEEK_END); len=ftell(stream);

 实例:

      本处设计了一个文件读写定位的例子，代码如下，其中seekwrite将整数值narray写入文件第"rec*sizeof(int)"处；函数seekread从文件的第"rec*sizeof(int)"位置中读取整数值存入narray.

     如果定位超过了文件的最大长度且执行了写入操作，文件长度将延长到当前位置，中间部分自动补0；

#include<stdio.h> void seekwrite(FILE　*fp,int narray,int rec)/*写入文件第rec个整数*/ { fseek(fp,sizeof(int)*rec,SEEK_SET); fwrite(&narray,sizeof(int),1,fp); } void seekread(FILE *fp,int *narray,int rec) { fseek(fp,sizeof(int)*rec,SEEK_SET); fread(narray,sizeof(int),1,fp); } void main() { FILE *fp; int narray[2]={100,200},narrayr[2]; if((fp=fopen("seek.dat","w+b"))==NULL) { printf("open seek.dat failed./n"); return ; } seekwrite(fp,narray[0],1);seekwrite(fp,narray[1],10); seekread(fp,narrayr,1); seekread(fp,narrayr+1,10); printf("now array[0]=%d,array[1]=%d",narrayr[0],narrayr[1]); fclose(fp); }

---

5:文件的状态

  每一个流对象内部都保持了两个指示状态：错误指示状态和文件结束状态，函数ferror和feof分别检查这两个状态，函数strerror显示错误的提示信息。

 

(1)文件的错误与结束状态

    #include<stdio.h> int ferror(FILE *stream); int feof(FILE *stream); void clearerr(FILE *stream); 

    当文件I/O发生错误时，调用ferror函数将返回非0值，否则返回0值。当文件结束时，调用feof函数返回非0值，否则返回0值，函数clearerr清除文件错误标志和EOF标志。

   实例：

   读取文件"/etc/passwd"，当文件结束时自动退出。

  #include<stdio.h> void main() { FILE *fp; char buf[1024]; if((fp=fopen("/etc/passwd","r"))==NULL) { printf("open file /etc/passwd failed./n"); return ; } while(!feof(fp)) { fgets(buf,sizeof(buf),fp); if(feof(fp)) break; fputs(buf,stderr); } fclose(fp); }  

 

(2)文件的错误信息

    错误状态指示器仅能判断错误是否发生，不能明确错误的内容，标准文件编程库用于明确错误信息的函数如下：

    extern int errno;

    #include<string.h>

    char *strerror(int errnum);

 

  其中外部变量errno代表了发生错误的代码，函数strerror获取第errnum号错误的详细信息。

 

 

---

 

6：文件的缓冲

   所谓文件写缓冲，是指文件流在执行输出操作时，并不立刻将数据写入文件，而是先把数据累计到缓冲区，再以块为单位批量输出到文件中，同理，文件读缓冲是指文件流在执行输入操作时，以块为单位读取文件内容，多余的数据存储在内存中。如果下次读操作的内容刚好在同一块中，则可以直接返回结果，避免一次输入操作。通过缓冲技术，可以减少低级I/O函数read和write函数的调用次数，从而大大提高软件执行效率。

  1)缓冲模式

   标准文件编程库采用FILE类型描述文件流，与低级I/O函数相比，最大的特性就是应用及增加了缓冲功能(低级I/O函数只使用了文件系统自带的缓冲功能)，文件的输入输出以"缓冲块"为单位批量完成，并且根据"缓冲块"大小，提供了三种缓冲模式。

   (1)全缓冲(_IOFBF)：一般读写普通磁盘文件采用全缓冲模式。

   (2)行缓冲(_IOLBF)：比如调用fgets函数从标准输入流stdin中输入字符，当且仅当客户输入回车换行时，函数才返回。

   (3)无缓冲(_IONBF)：比如stderr采用无缓冲模式；

  

 2)缓冲函数

   #include<stdio.h> void setbuf(FILE *stream,char *buf); int setvbuf(FILE *stream,char *buf,int type,size_t size); int fflush(FILE *stream);

   setbuf设置文件流stream的缓冲区，参数buf指向一个大小为BUFSIZ的内存块，调用成功后，文件流stream使用该内存块作为新的缓冲区。倘若buf是空指针NULL，文件流stream的缓冲将被完全关闭。缓冲区内存块的定义一般为：

   char buf[BUFSIZ]; ---其中BUFSIZ是stdio.h中的常数，代表缓冲区的大小，常为256的整数倍。

   setvbuf设置了文件流stream的缓冲区和缓冲模式，缓冲模式由参数type确定.

   任何时候，都可以使用fflush刷新缓冲区，并将缓冲区的内容强制输出到文件中，参数stream指明了更新的 文件流，当其值为NULL时，系统将刷新全部文件流的缓冲区。

  实例：

  本处设计了一个缓冲显示的实例：

  #include<stdio.h> void main() { printf(1---1); /*fflush(stdout);*/ fprintf(stderr,"2---2"); printf("3---3/n"); fprintf(stderr,"4--4/n"); }

 

 

 

 

 

---

 

7:项目：通用函数库之调试功能库封装

   1)调试库内容：

      格式化日志输出

      十六进制日志输出

      信息判断

   2)调试库设计

     (1)PrintLog

      格式化日志输出函数，其原型为：

      int PrintLog(FILE *fp,const char *pformat,...);

      /*-----debug.c-----*/ #include<stdio.h> #include<stdarg.h> #include<comlib.h> int PrintLog(FILE *fp,const char *pfromat,...) { va_list _va_list; TIMESTRU timestru; char szBuf[1024]; int nLen; if(pformat==NULL||pfile==NULL) return -1;/*判断指针是否yes*/ timestu=GetTime(); nLen=sprintf(szBuf,"%04d.%02d.%02d %02d:%02d:%02d. [%d]: ",timestru.nYear,timestru.nMon,timestru.nDay,timestru.nHour,timestru.nMin,timestru.nSec,getpid()); va_start(_va_list,pformat); nLen+=vsprintf(szBuf+nLen,pformat,_va_list); va_end(_va_list); nLen+=sprintf(szBuf+nLen,"/n"); if(fputs(szBfu,pfile)!=EOF && fflush(pfile)!=EOF) return 0;/*输出并刷新文件流*/ return -2;/*错误返回*/ }

   

     (2)PrintTraceLog

        int PrintTraceLog(const char *pformat,...);

        核心代码

        if((fp=open(TRACE_FILE),"a")!=NULL) { ret=PrintTraceLog(fp,szBuf); fclose(fp); return(set); }

 

  (3) Verify

       信息判断函数，其原型为：

      int Verify(int bStatus,const char *szBuf,const char *szFile,int nLine);

     

 

  (5)调试库应用实例：

   #include<stdio.h> void main() { int i=10000; PrintLog(stderr,"This is test[%d]/n"); PrintTraceLOg("This is test [%d]/n"); PrintTraceLog(----------------); Verify(0,NULL,_FILE_,_LINE_); PrintTraceLog("---------------"); Verify(0); PrintTraceLog("---------------"); Verify(1); }

  

 

 

 

 

 

 

 

 

 

 

 

 

 

---

---

2:文件的无格式读写

  标准程序编程对文件流的输入输出操作，能以无格式方式读写，也可以实现有格式读写，无格式读写，分为字符读写、按行读写、按块读写；

---