UNIX环境高级编程05.pdf

《UNIX环境高级编程05.pdf》由会员分享，可在线阅读，更多相关《UNIX环境高级编程05.pdf（19页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、下载第5章标 准 I/O 库5.1 引言本章说明标准 I/O库。因为不仅在 U N I X而且在很多操作系统上都实现此库，所以它由ANSI C标准说明。标准I/O库处理很多细节，例如缓存分配，以优化长度执行I/O等。这样使用户不必担心如何选择使用正确的块长度（如3.9节中所述）。标准I/O库是在系统调用函数基础上构造的，它便于用户使用，但是如果不较深入地了解库的操作，也会带来一些问题。标准I/O库是由Dennis Ritchie在1 9 7 5年左右编写的。它是由Mike Lesk编写的可移植I/O库的主要修改版本。令人惊异的是，1 5年后制订的标准I/O库对它只作了极小的修改。5.2 流和F

2、 I L E对象在第3章中，所有I/O函数都是针对文件描述符的。当打开一个文件时，即返回一个文件描述符，然后该文件描述符就用于后读的 I/O操作。而对于标准 I/O库，它们的操作则是围绕流（s t r e a m）进行的（请勿将标准I/O术语流与系统V的STREAMS I/O系统相混淆）。当用标准I/O库打开或创建一个文件时，我们已使一个流与一个文件相结合。当打开一个流时，标准I/O函数f o p e n返回一个指向F I L E对象的指针。该对象通常是一个结构，它包含了I/O库为管理该流所需要的所有信息：用于实际 I/O的文件描述符，指向流缓存的指针，缓存的长度，当前在缓存中的字符数，出错标

3、志等等。应用程序没有必要检验 F I L E对象。为了引用一个流，需将 F I L E指针作为参数传递给每个标准I/O函数。在本书中，我们称指向F I L E对象的指针(类型为F I L E*)为文件指针。在本章中，我们以U N I X系统为例，说明标准I/O库。正如前述，此标准库已移到除U N I X以外的很多系统中。但是为了说明该库实现的一些细节，我们选择U N I X实现作为典型进行介绍。5.3 标准输入、标准输出和标准出错对一个进程预定义了三个流，它们自动地可为进程使用：标准输入、标准输出和标准出错。在3.2节中我们曾用文件描述符S T D I N _ F I L E N O,S T

4、D O U T _ F I L E N O和S T D E R R _ F I L E N O分别表示它们。这三个标准I/O流通过预定义文件指针s t d i n,s t d o u t和s t d e r r加以引用。这三个文件指针同样定义在头文件中。5.4 缓存标准I/O提供缓存的目的是尽可能减少使用 r e a d和w r i t e调用的数量（见表3-1，其中显示了在不同缓存长度情况下，为执行 I/O所需的C P U时间量）。它也对每个I/O流自动地进行缓存管理，避免了应用程序需要考虑这一点所带来的麻烦。不幸的是，标准 I/O库令人最感迷惑的也是它的缓存。标准I/O提供了三种类型的缓存

5、：(1)全缓存。在这种情况下，当填满标准I/O缓存后才进行实际I/O操作。对于驻在磁盘上的文件通常是由标准I/O库实施全缓存的。在一个流上执行第一次I/O操作时，相关标准I/O函数通常调用m a l l o c（见7.8节）获得需使用的缓存。术语刷新（f l u s h）说明标准I/O缓存的写操作。缓存可由标准I/O例程自动地刷新（例如当填满一个缓存时），或者可以调用函数 ff l u s h刷新一个流。值得引起注意的是在 U N I X环境中，刷新有两种意思。在标准 I/O库方面，刷新意味着将缓存中的内容写到磁盘上（该缓存可以只是局部填写的）。在终端驱动程序方面（例如在第11章中所述的t c

6、 f l u s h函数），刷新表示丢弃已存在缓存中的数据。(2)行缓存。在这种情况下，当在输入和输出中遇到新行符时，标准 I/O库执行I/O操作。这允许我们一次输出一个字符（用标准 I/O fputc函数），但只有在写了一行之后才进行实际 I/O操作。当流涉及一个终端时（例如标准输入和标准输出），典型地使用行缓存。对于行缓存有两个限制。第一个是：因为标准 I/O库用来收集每一行的缓存的长度是固定的，所以只要填满了缓存，那么即使还没有写一个新行符，也进行 I/O操作。第二个是：任何时候只要通过标准输入输出库要求从(a)一个不带缓存的流，或者(b)一个行缓存的流（它预先要求从内核得到数据）得到输

7、入数据，那么就会造成刷新所有行缓存输出流。在(b)中带了一个在括号中的说明的理由是，所需的数据可能已在该缓存中，它并不要求内核在需要该数据时才进行该操作。很明显，从不带缓存的一个流中进行输入（(a)项）要求当时从内核得到数据。(3)不带缓存。标准I/O库不对字符进行缓存。如果用标准 I/O函数写若干字符到不带缓存的流中，则相当于用 w r i t e系统调用函数将这些字符写至相关联的打开文件上。标准出错流s t d e r r通常是不带缓存的，这就使得出错信息可以尽快显示出来，而不管它们是否含有一个新行字符。ANSI C要求下列缓存特征：(1)当且仅当标准输入和标准输出并不涉及交互作用设备时，

8、它们才是全缓存的。(2)标准出错决不会是全缓存的。但是，这并没有告诉我们如果标准输入和输出涉及交互作用设备时，它们是不带缓存的还是行缓存的，以及标准输出是不带缓存的，还是行缓存的。S V R 4和4.3+B S D的系统默认使用下列类型的缓存：标准出错是不带缓存的。如若是涉及终端设备的其他流，则它们是行缓存的；否则是全缓存的。对任何一个给定的流，如果我们并不喜欢这些系统默认，则可调用下列两个函数中的一个更改缓存类型：#include void setbuf(FILE*f p,char*b u f);int setvbuf(FILE*f p,char*b u f,int m o d e,size

9、_t s i z e);返回：若成功则为0，若出错则为非0这些函数一定要在流已被打开后调用（这是十分明显的，因为每个函数都要求一个有效的文件9 2U N I X环境高级编程下载指针作为它们的第一个参数），而且也应在对该流执行任何一个其他操作之前调用。可以使用s e t b u f函数打开或关闭缓存机制。为了带缓存进行 I/O，参数buf 必须指向一个长度为B U F S I Z的缓存（该常数定义在中）。通常在此之后该流就是全缓存的，但是如果该流与一个终端设备相关，那么某些系统也可将其设置为行缓存的。为了关闭缓存，将 b u f设置为N U L L。使用s e t v b u f，我们可以精确地

10、说明所需的缓存类型。这是依靠m o d e参数实现的：_IOFBF 全缓存_IOLBF 行缓存_IONBF 不带缓存如果指定一个不带缓存的流，则忽略buf 和size 参数。如果指定全缓存或行缓存，则buf 和s i z e可以可选择地指定一个缓存及其长度。如果该流是带缓存的，而 buf 是N U L L，则标准I/O库将自动地为该流分配适当长度的缓存。适当长度指的是由 s t r u c t结构中的成员s t _ b l k s i z e所指定的值（见4.2节）。如果系统不能为该流决定此值（例如若此流涉及一个设备或一个管道），则分配长度为B U F S I Z的缓存。伯克利系统首先使用s

11、t _ b l k s i z e表示缓存长度。较早的系统V版本使用标准I/O常数B U F S I Z（其典型值是1 0 2 4）。即使4.3+B S D使用s t _ b l k s i z e决定最佳的I/O缓存长度，它仍将B U F S I Z设置为1 0 2 4。表5-1列出了这两个函数的动作，以及它们的各个选择项。表5-1 setbuf 和setvbuf 函数函数m o d eb u f缓存及长度缓存的类型s e t b u fn o n n u l l长度为B U F S I Z的用户缓存全缓存或行缓存N U L L（无缓存）不带缓存_ I O F B Fn o n n u l

12、l长度为s i z e的用户缓存全缓存N U L L合适长度的系统缓存s e t v b u f_ I O L B Fn o n n u l l长度为s i z e的用户缓存行缓存N U L L合适长度的系统缓存_ I O N B F忽略无缓存不带缓存要了解，如果在一个函数中分配一个自动变量类的标准 I/O缓存，则从该函数返回之前，必须关闭该流。（7.8节将对此作更多讨论。）另外，S V R 4将缓存的一部分用于它自己的管理操作，所以可以存放在缓存中的实际数据字节数少于 s i z e。一般而言，应由系统选择缓存的长度，并自动分配缓存。在这样处理时，标准I/O库在关闭此流时将自动释放此缓存。任

13、何时候，我们都可强制刷新一个流。#i n c l u d e int fflush(FILE*f p);返回：若成功则为0，若出错则为E O F第5章标 准 I/O 库9 3下载此函数使该流所有未写的数据都被传递至内核。作为一种特殊情形，如若 f p是N U L L，则此函数刷新所有输出流。传送一个空指针以强迫刷新所有输出流，这是由ANSI C新引入的。非ANSI C库（例如较早的系统V版本和4.3 B S D）并不支持此种特征。5.5 打开流下列三个函数可用于打开一个标准I/O流。#include FILE*fopen(const char*p a t h n a m e,const cha

14、r*t y p e);FILE*freopen(const char*p a t h n a m e,const char*t y p e,FILE*f p);FILE*fdopen(int f i l e d e s,const char*t y p e);三个函数的返回：若成功则为文件指针，若出错则为 N U L L这三个函数的区别是：(1)fopen打开路径名由pathname 指示的一个文件。(2)freopen在一个特定的流上(由f p指示)打开一个指定的文件（其路径名由pathname 指示），如若该流已经打开，则先关闭该流。此函数一般用于将一个指定的文件打开为一个预定义的流：标准

15、输入、标准输出或标准出错。(3)fdopen取一个现存的文件描述符（我们可能从 o p e n,d u p,d u p 2,f c n t l或p i p e函数得到此文件描述符），并使一个标准的I/O流与该描述符相结合。此函数常用于由创建管道和网络通信通道函数获得的插述符。因为这些特殊类型的文件不能用标准 I/O fopen函数打开，首先必须先调用设备专用函数以获得一个文件描述符，然后用f d o p e n使一个标准I/O流与该描述符相结合。f o p e n和f r e o p e n是ANSI C的所属部分。而ANSI C并不涉及文件描述符，所以仅有P O S I X.1具有f d o

16、 p e n。t y p e参数指定对该I/O流的读、写方式，ANSI C规定t y p e参数可以有1 5种不同的值，它们示于表5-2中。表5-2 打开标准I/O流的t y p e参数t y p e说明r 或 r b为读而打开w 或 w b使文件成为0长，或为写而创建a 或 a b添加；为在文件尾写而打开，或为写而创建r+或 r+b 或 r b+为读和写而打开w+或 w+b 或 w b+使文件为0长，或为读和写而打开a+或 a+b 或 a b+为在文件尾读和写而打开或创建9 4U N I X环境高级编程下载使用字符b作为t y p e的一部分，使得标准 I/O系统可以区分文本文件和二进制文件

17、。因为U N I X内核并不对这两种文件进行区分，所以在 U N I X系统环境下指定字符 b作为t y p e的一部分实际上并无作用。对于f d o p e n，t y p e参数的意义则稍有区别。因为该描述符已被打开，所以 f d o p e n为写而打开并不截短该文件。(例如，若该描述符原来是由 o p e n函数打开的，该文件那时已经存在，则其O _ T R U N C标志将决定是否截短该文件。f d o p e n函数不能截短它为写而打开的任一文件。）另外，标准I/O添加方式也不能用于创建该文件（因为如若一个描述符引用一个文件，则该文件一定已经存在）。当用添加类型打开一文件后，则每次

18、写都将数据写到文件的当前尾端处。如若有多个进程用标准I/O添加方式打开了同一文件，那么来自每个进程的数据都将正确地写到文件中。4.3+B S D以前的伯克利版本以及K e r n i g h a n和R i t c h i e1 9 8 81 7 7页上所示的简单版本并不能正确地处理添加方式。这些版本在打开流时，调用 l s e e k到达文件尾端。在涉及多个进程时，为了正确地支持添加方式，该文件必须用 O _ A P P E N D标志打开，我们已在3.3节中对此进行了讨论。在每次写前，做一次 l s e e k操作同样也不能正确工作（如同在3.11节中讨论的一样）。当以读和写类型打开一文件

19、时（t y p e中+号），具有下列限制：如果中间没有ff l u s h、f s e e k、f s e t p o s或r e w i n d，则在输出的后面不能直接跟随输入。如果中间没有f s e e k、f s e t p o s或r e w i n d,或者一个输出操作没有到达文件尾端，则在输入操作之后不能直接跟随输出。按照表5-2，我们在表5-3中列出了打开一个流的六种不同的方式。表5-3 打开一个标准I/O流的六种不同的方式限制rwar+w+a+文件必须已存在擦除文件以前的内容流可以读流可以写流只可在尾端处写注意，在指定w或a类型创建一个新文件时，我们无法说明该文件的存取许可权位

20、（第 3章中所述的o p e n函数和c r e a t函数则能做到这一点）。P O S I X.1要求以这种方式创建的文件具有下列存取许可权：S _ I R U S RS _ I W U S RS _ I R G R PS _ I W G R PS _ I R O T HS _ I W O T H除非流引用终端设备，否则按系统默认，它被打开时是全缓存的。若流引用终端设备，则该流是行缓存的。一旦打开了流，那么在对该流执行任何操作之前，如果希望，则可使用前节所述的s e t b u f和s e t v b u f改变缓存的类型。调用f c l o s e关闭一个打开的流。#include int

21、 fclose(FILE*f p);第5章标 准 I/O 库9 5下载返回：若成功则为0，若出错则为E O F在该文件被关闭之前，刷新缓存中的输出数据。缓存中的输入数据被丢弃。如果标准 I/O库已经为该流自动分配了一个缓存，则释放此缓存。当一个进程正常终止时（直接调用e x i t函数，或从m a i n函数返回），则所有带未写缓存数据的标准I/O流都被刷新，所有打开的标准I/O流都被关闭。5.6 读和写流一旦打开了流，则可在三种不同类型的非格式化 I/O中进行选择，对其进行读、写操作。（5.11节说明了格式化I/O函数，例如p r i n t f和s c a n f。）(1)每次一个字符的I

22、/O。一次读或写一个字符，如果流是带缓存的，则标准I/O函数处理所有缓存。(2)每次一行的I/O。使用f g e t s和f p u t s一次读或写一行。每行都以一个新行符终止。当调用f g e t s时，应说明能处理的最大行长。5.7节将说明这两个函数。(3)直接I/O。f r e a d和f w r i t e函数支持这种类型的I/O。每次I/O操作读或写某种数量的对象，而每个对象具有指定的长度。这两个函数常用于从二进制文件中读或写一个结构。5.9节将说明这两个函数。直接I/O(direct I/O)这个术语来自ANSI C标准，有时也被称为：二进制 I/O、一次一个对象I/O、面向记录

23、的I/O或面向结构的I/O。5.6.1 输入函数以下三个函数可用于一次读一个字符。#include int getc(FILE*f p);int fgetc(FILE*f p);int getchar(void);三个函数的返回：若成功则为下一个字符，若已处文件尾端或出错则为 E O F函数g e t c h a r等同于g e t c(s t d i n)。前两个函数的区别是g e t c可被实现为宏，而f g e t c则不能实现为宏。这意味着：(1)getc的参数不应当是具有副作用的表达式。(2)因为f g e t c一定是个函数，所以可以得到其地址。这就允许将 f g e t c的地址

24、作为一个参数传送给另一个函数。(3)调用f g e t c所需时间很可能长于调用g e t c,因为调用函数通常所需的时间长于调用宏。检验一下头文件的大多数实现，从中可见g e t c是一个宏，其编码具有较高的工作效率。这三个函数以unsigned char 类型转换为i n t的方式返回下一个字符。说明为不带符号的理由是，如果最高位为1也不会使返回值为负。要求整型返回值的理由是，这样就可以返回所有可能的字符值再加上一个已发生错误或已到达文件尾端的指示值。在 中的常数E O F被要9 6U N I X环境高级编程下载求是一个负值，其值经常是 1。这就意味着不能将这三个函数的返回值存放在一个字符

25、变量中，以后还要将这些函数的返回值与常数E O F相比较。注意，不管是出错还是到达文件尾端，这三个函数都返回同样的值。为了区分这两种不同的情况，必须调用f e r r o r或f e o f。#include int ferror(FILE*f p);int feof(FILE*f p);两个函数返回：若条件为真则为非0（真），否则为0（假）void clearerr(FILE*f p);在大多数实现的F I L E对象中，为每个流保持了两个标志：出错标志。文件结束标志。调用c l e a r e r r则清除这两个标志。从一个流读之后，可以调用u n g e t c将字符再送回流中。#inc

26、lude int ungetc(int c,FILE*f p);返回：若成功则为C，若出错则为E O F送回到流中的字符以后又可从流中读出，但读出字符的顺序与送回的顺序相反。应当了解，虽然ANSI C允许支持任何数量的字符回送的实现，但是它要求任何一种实现都要支持一个字符的回送功能。回送的字符，不一定必须是上一次读到的字符。E O F不能回送。但是当已经到达文件尾端时，仍可以回送一字符。下次读将返回该字符，再次读则返回 E O F。之所以能这样做的原因是一次成功的u n g e t c调用会清除该流的文件结束指示。当正在读一个输入流，并进行某种形式的分字或分记号操作时，会经常用到回送字符操作。

27、有时需要先看一看下一个字符，以决定如何处理当前字符。然后就需要方便地将刚查看的字符送回，以便下一次调用g e t c时返回该字符。如果标准I/O库不提供回送能力，就需将该字符存放到一个我们自己的变量中，并设置一个标志以便判别在下一次需要一个字符时是调用 g e t c，还是从我们自己的变量中取用。5.6.2 输出函数对应于上面所述的每个输入函数都有一个输出函数。#include int putc(int c,FILE*f p);int fputc(int c,FILE*f p）;第5章标 准 I/O 库9 7下载int putchar(int c);三个函数返回：若成功则为C，若出错则为E O

28、 F与输入函数一样，putchar(c)等同于putc(c,stdout)，putc 可被实现为宏，而fputc 则不能实现为宏。5.7 每次一行I/O下面两个函数提供每次输入一行的功能。#include char*fgets(char*b u f,int n，FILE*f p);char*gets(char*b u f);两个函数返回：若成功则为b u f，若已处文件尾端或出错则为N U L L这两个函数都指定了缓存地址，读入的行将送入其中。g e t s从标准输入读，而f g e t s则从指定的流读。对于f g e t s，必须指定缓存的长度n。此函数一直读到下一个新行符为止，但是不超过

29、 n1个字符，读入的字符被送入缓存。该缓存以 n u l l字符结尾。如若该行，包括最后一个新行符的字符数超过n1，则只返回一个不完整的行，而且缓存总是以 n u l l字符结尾。对f g e t s的下一次调用会继续读该行。g e t s是一个不推荐使用的函数。问题是调用者在使用 g e t s时不能指定缓存的长度。这样就可能造成缓存越界（如若该行长于缓存长度），写到缓存之后的存储空间中，从而产生不可预料的后果。这种缺陷曾被利用，造成1 9 8 8年的因特网蠕虫事件。有关说明请见1 9 8 9.6.Communications of the ACM（vol.32,no.6）。g e t s与

30、f g e t s的另一个区别是，g e t s并不将新行符存入缓存中。这两个函数对新行符进行处理方面的差别与 U N I X的进展有关。早在V 7的手册中就说明：“为了向后兼容，g e t s删除新行符，而f g e t s则保持新行符。”虽然ANSI C要求提供g e t s,但请不要使用它。f p u t s和p u t s提供每次输出一行的功能。#include int fputs(const char*s t r,FILE*f p);int puts(const char*s t r);两个函数返回：若成功则为非负值，若出错则为 E O F函数f p u t s将一个以n u l l

31、符终止的字符串写到指定的流，终止符 n u l l不写出。注意，这并不一定是每次输出一行，因为它并不要求在 n u l l符之前一定是新行符。通常，在 n u l l符之前是一个新行符，但并不要求总是如此。p u t s将一个以n u l l符终止的字符串写到标准输出，终止符不写出。但是，p u t s然后又将一个新行符写到标准输出。9 8U N I X环境高级编程下载p u t s并不像它所对应的g e t s那样不安全。但是我们还是应避免使用它，以免需要记住它在最后又加上了一个新行符。如果总是使用 f g e t s和fputs,那么就会熟知在每行终止处我们必须自己加一个新行符。5.8 标

32、准I/O的效率使用前面所述的函数，我们应该对标准 I/O系统的效率有所了解。程序 5-1类似于程序3-3，它使用g e t c和p u t c将标准输入复制到标准输出。这两个函数可以实现为宏。程序5-1 用g e t c和p u t c将标准输入复制到标准输出可以用f g e t c和f p u t c改写该程序，这两个一定是函数，而不是宏（没有给出对源代码更改的细节）。最后，我们还编写了一个读、写行的版本，见程序5-2。程序5-2 用f g e t s和f p u t s将标准输入复制到标准输出注意，在程序5-1和程序5-2中，没有显式地关闭标准I/O流。我们知道e x i t函数将会刷新任

33、何未写的数据，然后关闭所有打开的流（我们将在 8.5节讨论这一点）。将这三个程序的时间与表3-1中的时间进行比较是很有趣的。表 5-4中显示了对同一文件（1.5 M字节,30,000行）进行操作所得的数据。第5章标 准 I/O 库9 9下载表5-4 使用标准I/O例程得到的时间结果函数用户C P U（秒）系统C P U（秒）时钟时间（秒）程序正文字节数表3-1中的最佳时间0.00.30.3f g e t s,f p u t s2.20.32.61 8 4g e t c,p u t c4.30.34.83 8 4f g e t c,f p u t c4.60.35.01 5 2表3-1中的单字节

34、时间2 3.83 9 7.94 2 3.4对于这三个标准I/O版本的每一个，其用户C P U时间都大于表3-1中的最佳r e a d版本，因为每次读一个字符版本中有一个要执行 1 5 0万次的循环，而在每次读一行的版本中有一个要执行30 000次的循环。在r e a d版本中，其循环只需执行1 8 0次（对于缓存长度为8 1 9 2字节）。因为系统C P U时间都相同，所以用户C P U时间的差别造成了时钟时间的差别。系统C P U时间相同的原因是因为所有这些程序对内核提出的读、写请求数相同。注意，使用标准I/O例程的一个优点是无需考虑缓存及最佳 I/O长度的选择。在使用f g e t s时需

35、要考虑最大行长，但是最佳I/O长度的选择要方便得多。表5-4中的最后一列是每个m a i n函数的文本空间字节数（由 C编译产生的机器指令）。从中可见，使用g e t c的版本在文本空间中作了 g e t c和p u t c的宏代换，所以它所需使用的指令数超过了调用f g e t c和f p u t c函数所需指令数。观察g e t c版本和f g e t c版本在用户C P U时间方面的差别，可以看到在程序中作宏代换和调用两个函数在进行本测试的系统上并没有造成多大差别。使用每次一行I/O版本其速度大约是每次一个字符版本的两倍（包括用户 C P U时间和时钟时间）。如果f g e t s和f

36、p u t s函数用g e t c和p u t c实现（例如，见K e r n i g h a n和R i t c h i e1 9 8 8的7.7节），那么，可以预期f g e t s版本的时间会与g e t c版本相接近。实际上，可以预料每次一行的版本会更慢一些，因为除了现已存在的 60 000次函数调用外还需增加3百万次宏调用。而在本测试中所用的每次一行函数是用m e m c c p y(3)实现的。通常，为了提高效率，m e m c c p y函数用汇编语言而非C语言编写。这些时间数字的最后一个有趣之处在于：f g e t c版本较表3-1中B U F F S I Z E1的版本要快得

37、多。两者都使用了约3百万次的函数调用，而f g e t c版本的速度在用户C P U时间方面，大约是后者的5倍，而在时钟时间方面则几乎是1 0 0倍。造成这种差别的原因是：使用r e a d的版本执行了3百万次函数调用，这也就引起 3百万次系统调用。而对于f g e t c版本，它也执行3百万次函数调用，但是这只引起3 6 0次系统调用。系统调用与普通的函数调用相比是很花费时间的。需要声明的是这些时间结果只在某些系统上才有效。这种时间结果依赖于很多实现的特征，而这种特征对于不同的 U N I X系统却可能是不同的。尽管如此，使这样一组数据，并对各种版本的差别作出解释，这有助于我们更好地了解系统

38、。在本节及3.9节中我们学到的基本事实是：标准I/O库与直接调用r e a d和w r i t e函数相比并不慢很多。我们观察到使用g e t c和p u t c复制1 M字节数据大约需3.0秒C P U时间。对于大多数比较复杂的应用程序，最主要的用户C P U时间是由应用本身的各种处理花费的，而不是由标准I/O例程消耗的。5.9 二进制I/O5.6节中的函数以一次一个字符或一次一行的方式进行操作。如果为二进制 I/O，那么我们更愿意一次读或写整个结构。为了使用 g e t c或p u t c做到这一点，必须循环通过整个结构，一次1 0 0U N I X环境高级编程下载读或写一个字节。因为 f

39、 p u t s在遇到n u l l字节时就停止，而在结构中可能含有 n u l l字节，所以不能使用每次一行函数实现这种要求。相类似，如果输入数据中包含有n u l l字节或新行符，则f g e t s也不能正确工作。因此，提供了下列两个函数以执行二进制 I/O操作。#include size_t fread(void*p t r,size_t s i z e,size_t n o b j,FILE*f p);size_t fwrite(const void*p t r,size_t s i z e,size_t n o b j,FILE*f p);两个函数的返回：读或写的对象数这些函数有两

40、个常见的用法：(1)读或写一个二进制数组。例如，将一个浮点数组的第 2至第5个元素写至一个文件上，可以写作：float data 1 0;if(fwrite(&data2,sizeof(float),4,fp)!=4)err_sys(fwrite error);其中，指定s i z e为每个数组元素的长度，n o b j为欲写的元素数。(2)读或写一个结构。例如，可以写作：struct short count;long total;char name N A M E S I Z E；item;if(fwrite(&item,sizeof(item),1,fp)!=1)err_sys(fwrit

41、e error);其中，指定s i z e为结构的长度，n o b j为1（要写的对象数）。将这两个例子结合起来就可读或写一个结构数组。为了做到这一点，s i z e应当是该结构的s i z e o f,n o b j应是该数组中的元素数。f r e a d和f w r i t e返回读或写的对象数。对于读，如果出错或到达文件尾端，则此数字可以少于n o b j。在这种情况，应调用f e r r o r或f e o f以判断究竟是那一种情况。对于写，如果返回值少于所要求的n o b j，则出错。使用二进制I/O的基本问题是，它只能用于读已写在同一系统上的数据。多年之前，这并无问题（那时，所有

42、U N I X系统都运行于P D P-11上），而现在，很多异构系统通过网络相互连接起来，而且，这种情况已经非常普遍。常常有这种情形，在一个系统上写的数据，在另一个系统上处理。在这种环境下，这两个函数可能就不能正常工作，其原因是：(1)在一个结构中，同一成员的位移量可能随编译程序和系统的不同而异（由于不同的对准要求）。确实，某些编译程序有一选择项，它允许紧密包装结构（节省存储空间，而运行性能则可能有所下降）或准确对齐，以便在运行时易于存取结构中的各成员。这意味着即使在单一系统上，一个结构的二进制存放方式也可能因编译程序的选择项而不同。(2)用来存储多字节整数和浮点值的二进制格式在不同的系统结构

43、间也可能不同。在不同系统之间交换二进制数据的实际解决方法是使用较高层次的协议。关于网络协议使用的交换二进制数据的某些技术，请参阅S t e v e n s1 9 9 0的1 8.2节。第5章标 准 I/O 库1 0 1下载在8.1 3节中，我们将再回到 f r e a d函数，那时将用它读一个二进制结构U N I X的进程记账记录。5.10 定位流有两种方法定位标准I/O流。(1)ftell和f s e e k。这两个函数自V 7以来就存在了，但是它们都假定文件的位置可以存放在一个长整型中。(2)fgetpos和f s e t p o s。这两个函数是新由ANSI C引入的。它们引进了一个新的

44、抽象数据类型f p o s _ t，它记录文件的位置。在非U N I X系统中，这种数据类型可以定义为记录一个文件的位置所需的长度。需要移植到非U N I X系统上运行的应用程序应当使用f g e t p o s和f s e t p o s。#include long ftell(FILE*f p);返回：若成功则为当前文件位置指示，若出错则为 1 Lint fseek(FILE*f p,long o f f s e t,int w h e n c e);返回：若成功则为0，若出错则为非0void rewind(FILE*f p);对于一个二进制文件，其位置指示器是从文件起始位置开始度量，并以

45、字节为计量单位的。f t e l l用于二进制文件时，其返回值就是这种字节位置。为了用 f s e e k定位一个二进制文件，必须指定一个字节 o f f s e t，以及解释这种位移量的方式。w h e n c e的值与3.6节中l s e e k函数的相同：S E E K _ S E T表示从文件的起始位置开始，S E E K _ C U R表示从当前文件位置，S E E K _ E N D表示从文件的尾端。ANSI C并不要求一个实现对二进制文件支持 S E E K _ E N D规格说明，其原因是某些系统要求二进制文件的长度是某个幻数的整数倍，非实际内容部分则充填为 0。但是在U N

46、I X中，对于二进制文件S E E K _ E N D是得到支持的。对于文本文件，它们的文件当前位置可能不以简单的字节位移量来度量。再一次，这主要也是在非 U N I X系统中，它们可能以不同的格式存放文本文件。为了定位一个文本文件，w h e n c e一定要是S E E K _ S E T，而且o f f s e t只能有两种值：0（表示反绕文件至其起始位置），或是对该文件的f t e l l所返回的值。使用r e w i n d函数也可将一个流设置到文件的起始位置。正如我们已提及的，下列两个函数是C标准新引进的。#include int fgetpos(FILE*f p,fpos_t*p

47、 o s);int fsetpos(FILE*f p,const fpos_t*p o s);两个函数返回：若成功则为0，若出错则为非0f g e t p o s将文件位置指示器的当前值存入由 p o s指向的对象中。在以后调用 f s e t p o s时，可以使用此值将流重新定位至该位置。1 0 2U N I X环境高级编程下载5.11 格式化I/O5.11.1 格式化输出执行格式化输出处理的是三个p r i n t f函数。#include int printf(const char*f o r m a t,.);int fprintf(FILE*f p,const char*f o r

48、 m a t,.);两个函数返回：若成功则为输出字符数，若输出出错则为负值int sprintf(char*b u f,const char*f o r m a t,.);返回：存入数组的字符数p r i n t f将格式化数据写到标准输出，f p r i n t f写至指定的流，s p r i n t f将格式化的字符送入数组b u f中。s p r i n t f在该数组的尾端自动加一个n u l l字节，但该字节不包括在返回值中。4.3 B S D定义s p r i n t f返回其第一个参数（缓存指针，类型为 c h a r*），而不是一个整型。ANSI C要求s p r i n t

49、f返回一个整型。注意，s p r i n t f可能会造成由b u f指向的缓存的溢出。保证该缓存有足够长度是调用者的责任。对这三个函数可能使用的各种格式变换，请参阅U N I X手册，或K e r n i g h a n和R i t c h i e1 9 8 8的附录B。下列三种p r i n t f族的变体类似于上面的三种，但是可变参数表(.)代换成了a rg。#i n c l u d e#i n c l u d e int vprintf(const char*f o r m a t,va_list a rg);int vfprintf(FILE*f p,const char*f o r

50、 m a t,va_list a rg);两个函数返回：若成功则为输出字符数，若输出出错则为负值int vsprintf(char*b u f,const char*f o r m a t,va_list a rg);返回：存入数组的字符数在附录B的出错例程中，将使用v s p r i n t f函数。关于ANSI C标准中有关可变长度参数表的详细说明请参阅 K e r n i g h a n和R i t c h i e1 9 8 8的7.3节。应当了解的是，由ANSI C提供的可变长度参数表例程（头文件和相关的例程）与由S V R 3（以及更早版本）和4.3 B S D提供的例程是不同的。5