Unix环境高级编程学习笔记（第五章）

第五章 标准I/O库

一、缓存

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

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

       (3) 不带缓存。标准I / O库不对字符进行缓存。如果用标准 I / O函数写若干字符到不带缓存
的流中，则相当于用 w r i t e系统调用函数将这些字符写至相关联的打开文件上。标准出错流
s t d e r r通常是不带缓存的，这就使得出错信息可以尽快显示出来，而不管它们是否含有一个新
行字符。

        下列两个函数可以更改缓存类型：

void setbuf(FILE *f p, char *b u f) ;
int setvbuf(FILE *f p, char *b u f, int m o d e, size_t s i z e) ;
返回：若成功则为0，若出错则为非0
这些函数一定要在流已被打开后调用而且也应在对该流执行任何一个其他操作之前调用。

可以使用s e t b u f函数打开或关闭缓存机制。为了带缓存进行 I / O，参数buf 必须指向一个长度为B U F S I Z的缓存（该常数定义在< s t d i o . h >中）。通常在此之后该流就是全缓存的，但是如果该流与一个终端设备相关，那么某些系统也可将其设置为行缓存的。为了关闭缓存，将 b u f设置为N U L L。
使用s e t v b u f，我们可以精确地说明所需的缓存类型。这是依靠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的缓存。

任何时候，我们都可强制刷新一个流。
# i n c l u d e < s t d i o . h >
int fflush(FILE *f p) ;
返回：若成功则为0，若出错则为E O F
此函数使该流所有未写的数据都被传递至内核。作为一种特殊情形，如若 f p是N U L L，则此函数刷新所有输出流。

二、打开或读写流

下列三个函数可用于打开一个标准I / O流。
#include <stdio.h>
FILE *fopen(const char *p a t h n a m e, const char *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 指示），
如若该流已经打开，则先关闭该流。此函数一般用于将一个指定的文件打开为一个预定义的流：
标准输入、标准输出或标准出错。
(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流与该描述符相结合。

 一旦打开了流，则可在三种不同类型的非格式化 I / O中进行选择，对其进行读、写操作。
(1) 每次一个字符的I / 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操作读或写某种数量的对象，
而每个对象具有指定的长度。这两个函数常用于从二进制文件中读或写一个结构。

以下三个函数可用于一次读一个字符。
#include <stdio.h>
int getc(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的地址作为一个参数传送给另一个函数。
(3) 调用f g e t c所需时间很可能长于调用g e t c ,因为调用函数通常所需的时间长于调用宏。检验一下< s t d i o . h >头文件的大多数实现，从中可见g e t c是一个宏，其编码具有较高的工作效率。
这三个函数以unsigned char 类型转换为i n t的方式返回下一个字符。说明为不带符号的理由
是，如果最高位为1也不会使返回值为负。要求整型返回值的理由是，这样就可以返回所有可
能的字符值再加上一个已发生错误或已到达文件尾端的指示值。在 < s t d i o . h >中的常数E O F被要求是一个负值，其值经常是－ 1。这就意味着不能将这三个函数的返回值存放在一个字符变量
中，以后还要将这些函数的返回值与常数E O F相比较。
注意，不管是出错还是到达文件尾端，这三个函数都返回同样的值。为了区分这两种不同的情况，必须调用f e r r o r或f e o f。
#include <stdio.h>
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将字符再送回流中。
#include <stdio.h>
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调用会清除该流的文件结束指示。
当正在读一个输入流，并进行某种形式的分字或分记号操作时，会经常用到回送字符操作。
有时需要先看一看下一个字符，以决定如何处理当前字符。然后就需要方便地将刚查看的字符
送回，以便下一次调用g e t c时返回该字符。对应于上面所述的每个输入函数都有一个输出函数。
#include <stdio.h>
int putc(int c, FILE *f p) ;
int fputc(int c, FILE *f p）;

int putchar(int c) ;
三个函数返回：若成功则为C，若出错则为E O F
与输入函数一样，putchar(c) 等同于putc (c, stdout)，putc 可被实现为宏，而fputc 则不能实现
为宏。

下面两个函数提供每次输入一行的功能。
#include <stdio.h>
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。此函数一直读到下一个新行符为止，但是不超过 n－1
个字符，读入的字符被送入缓存。该缓存以 n u l l字符结尾。如若该行，包括最后一个新行符的
字符数超过n－1，则只返回一个不完整的行，而且缓存总是以 n u l l字符结尾。对f g e t s的下一次
调用会继续读该行。
g e t s是一个不推荐使用的函数。问题是调用者在使用 g e t s时不能指定缓存的长度。这样就
可能造成缓存越界（如若该行长于缓存长度），写到缓存之后的存储空间中，从而产生不可预
料的后果。g e t s与f g e t s的另一个区别是，g e t s并不将新行符存入缓存中。

f p u t s和p u t s提供每次输出一行的功能。
#include <stdio.h>
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符终止的字符串写到指定的流，终止符 n u l l不写出。注意，这并不一定
是每次输出一行，因为它并不要求在 n u l l符之前一定是新行符。通常，在 n u l l符之前是一个新
行符，但并不要求总是如此。
p u t s将一个以n u l l符终止的字符串写到标准输出，终止符不写出。但是， p u t s然后又将一个
新行符写到标准输出。

下列两个函数以执行二进制I / O操作。
#include <stdio.h>
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) ;
两个函数的返回：读或写的对象数

有两种方法定位标准I / O流。
(1) ftell和f s e e k。这两个函数自V 7以来就存在了，但是它们都假定文件的位置可以存放在一个长整型中。
(2) fgetpos和f s e t p o s。这两个函数是新由ANSI C引入的。它们引进了一个新的抽象数据类
型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 <stdio.h>
long ftell(FILE *f p) ;
返回：若成功则为当前文件位置指示，若出错则为－ 1 L
int fseek(FILE *f p,long o f f s e t,int w h e n c e) ;
返回：若成功则为0，若出错则为非0
void rewind(指定一个字节o f f s e t，以及解释这种位移量的方式。

w h e n c e的值与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表示从
文件的尾端。

#include <stdio.h>
int fgetpos(FILE *f p, fpos_t *p o s) ;
int fsetpos(FILE *f p, const fpos_t *p o s) ;
两个函数返回：若成功则为0，若出错则为非0
 g e t p o s将文件位置指示器的当前值存入由 p o s指向的对象中。在以后调用f s e t p o s时，可以使用
此值将流重新定位至该位置。

执行格式化输出处理的是三个p r i n t f函数。
#include <stdio.h>
int printf(const char *f o r m a t, ...);
int fprintf(FILE *f p, const char *f o r 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字节，但该字节不包括在返回值中。

下列三种p r i n t f族的变体类似于上面的三种，但是可变参数表( . . . )代换成了a rg。
# i n c l u d e < s t d a r g . h >
# i n c l u d e < s t d i o . h >
int vprintf(const char *f o r m a t, va_list a rg) ;
int vfprintf(FILE *f p, const char *f o r 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) ;
返回：存入数组的字符数

执行格式化输入处理的是三个s c a n f函数:

# i n c l u d e < s t d i o . h >
int scanf(const char *f o r m a t, ...);
int fscanf(FILE *f p, const char *f o r m a t, ...);
int sscanf(const char *b u f, const char *f o r m a t, ...);
三个函数返回：指定的输入项数，若输入出错，或在任意变换前已至文件尾端则为 E O F

在U N I X中，标准I / O库最终都要调用第3章中说明的I / O例程。每个I / O流都有一个与其相关联的文件描述符，可以对一个流调用f i l e n o以获得其描述符。
#include <stdio.h>
int fileno(FILE *f p) ;
返回：与该流相关联的文件描述符
如果要调用d u p或f c n t l等函数，则需要此函数。

练习: 程序5-3   对各个标准I / O流打印缓存状态信息

标准I / O库提供了两个函数以帮助创建临时文件。
# i n c l u d e < s t d i o . h >
char *tmpnam(char *p t r) ;
返回：指向一唯一路径名的指针

FILE *tmpfile(void);

t m p n a m产生一个与现在文件名不同的一个有效路径名字符串。每次调用它时，它都产生一个不同的路径名，最多调用次数是T M P _ M A X。T M P _ M A X定义在< s t d i o . h >中。
若p t r是N U L L，则所产生的路径名存放在一个静态区中，指向该静态区的指针作为函数值返回。下一次再调用t m p n a m时，会重写该静态区。（这意味着，如果我们调用此函数多次，而且想保存路径名，则我们应当保存该路径名的副本，而不是指针的副本。）如若p t r不是N U L L，则认为它指向长度至少是L _ t m p n a m个字符的数组。（常数L _ t m p n a m定义在头文件< s t d i o . h >中。）所产生的路径名存放在该数组中，p t r也作为函数值返回。
t m p f i l e创建一个临时二进制文件（类型 w b +），在关闭该文件或程序结束时将自动删除这种文件。注意，U N I X对二进制文件不作特殊区分。
返回：若成功则为文件指针，若出错则为N U L L
t m p f i l e函数经常使用的标准U N I X技术是先调用t m p n a m产生一个唯一的路径名，然后立即u n l i n k它。

练习: 程序5-4   tmpnam和t m p f i l e函数实例

对一个文件解除连接并不删除其内容，关闭该文件时才删除其内容。
t e m p n a m是t m p n a m的一个变体，它允许调用者为所产生的路径名指定目录和前缀。
# include <stdio.h>
char   *tempnam(const char *d i re c t o ry, const char *p re f i x;
返回：指向一唯一路径名的指针
对于目录有四种不同的选择，并且使用第一个为真的作为目录：
(1) 如果定义了环境变量T M P D I R，则用其作为目录
(2) 如果参数d i re c t o ry非N U L L，则用其作为目录。
(3) 将< s t d i o . h >中的字符串P _ t m p d i r用作为目录。
(4) 将本地目录，通常是/ t m p ,用作为目录。
如果p re f i x非N U L L，则它应该是最多包含5个字符的字符串，用其作为文件名的头几个字符。
该函数调用m a l l o c函数分配动态存储区，用其存放所构造的路径名。当不再使用此路径名
时就可释放此存储区

在标准I / O库中，一个效率不高的不足之处是需要复制的数据量。当使用每次一行函数 g e t s和f p u t s时，通常需要复制两次数据：一次是在内核和标准 I / O缓存之间（当调用 r e a d和w r i t e时），第二次是在标准 I / O缓存和用户程序中的行缓存之间。快速 I / O库〔AT&T 1990a中的f i o ( 3 )〕避免了这一点，其方法是使读一行的函数返回指向该行的指针，而不是将该行复制到另一个缓存中。K o r n和Vo〔1 9 9 1〕说明了标准I / O库的另一种代替版：s f i o。这一软件包在速度上与f i o相近，通常快于标准I / O库。s f i o也提供了一些新的特征：推广了 I / O流，使其不仅可以代表文件，也可代表存储区；可以编写处理模块，并以栈方式将其压入 I / O流，这样就可以改变一个流的操作；较好的异常处理等。
K r i e g e r, Stumm和U n r a u〔1 9 9 2〕说明了另一个代换软件包，它使用了映照文件—m m a p函数，我们将在1 2 . 9节中说明此函数。该新软件包称为ASI(Alloc Stream Interface)。其程序界面类似于U N I X存储分配函数.与s f i o软件包相同，A S I使用指针力图减少数据复制量。