UNIX环境高级编程-标准I/O库

 

相关函数列表

1. //设置流的定向  
2. #include <stdio.h>  
3. #include <wchar.h>  
4. int fwide(FILE *fp, int mode);  
5.   
6. //标准输入，标准输出，标准错误  
7. #include <stdio.h>  
8. //stdin，stdout，stderr  
9.   
10. //设置缓冲区  
11. #include <stdio.h>  
12. void setbuf(FILE *restrict fp, char *restrict buf);  
13. int setvbuf(FILE *restrict fp, char *restrict buf, int mode, size_t size);  
14. //使用setvbuf，我们可以精确的说明所需的缓冲类型，这是用mode参数实现的  
15. //IOEBF  全缓冲  
16. //IOLBF  行缓冲  
17. //IONBF  不带缓冲  
18.   
19. //强制刷新流  
20. #include <stdio.h>  
21. int fflush(FILE *fp);  
22.   
23. //打开流  
24. #include <stdio.h>  
25. FILE *fopen(const char *restrict pathname, const char *restrict type);  
26. FILE *freopen(const char *restrict pathname, const char *restrict type,FILE *restrict fp);  
27. FILE *fdopen(int fd, const char *type);  
28.   
29. //关闭流  
30. #include <stdio.h>  
31. int fclose(FILE *fp);  
32.   
33.   
34.   
35. //读和写流  
36. //一次读一个字符  
37. #include <stdio.h>  
38. int getc(FILE *fp);  
39. int fgetc(FILE *fp);  
40. int getchar(void);  
41.   
42. //在调用各种输入输出函数(如putc,getc)时，如果出现错误，除了函数返回值可以反映外，还可以  
43. //使用ferror函数检查  
44. #include <stdio.h>  
45. int ferror(FILE *fp);  
46. int feof(FILE *fp);  
47. void clearerr(FILE *fp);  
48.   
49. //从流中读取数据以后，可以调用ungetc将字符再压送回流中  
50. #include <stdio.h>  
51. int ungetc(int c, File *fp);  
52.   
53. //输出函数  
54. #include <stdio.h>  
55. int putc(int c, FILE *fp);  
56. int fputc(int c, FILE *fp);  
57. int putchar(int c);  
58.   
59.   
60. //每次一行I/O  
61. #include <stdio.h>  
62. char *fgets(char *restrict buf, int n, FILE *restrict fp);  
63. char *gets(char *buf);  
64. int fputs(const char *restrict str, FILE *restrict fp);  
65. int puts(const char *str);  
66.   
67. //执行二进制I/O  
68. #include <stdio.h>  
69. size_t fread(void *restrict ptr, size_t size, size_t nobj, FILE *restrict fp);  
70. size_t fwrite(const void *restrict ptr, size_t size, size_t nobj, FILE *restrict fp);  
71.   
72.   
73. //定位标准I/O流  
74. #include <stdio.h>  
75. long ftell(FILE *fp);  
76. int fseek(FILE *fp, long offset, int whence);  
77. void rewind(FILE *fp);  
78.   
79. //其他，偏移量是off_t而非long意外，ftello和ftell相同，fseeko和fseek相同  
80. #include <stdio.h>  
81. off_t ftello(FILE *fp);  
82. int fseeko(FILE *fp, off_t offset, int whence);  
83.   
84. //fgetpos和fsetpos是IOS C标准引入的  
85. #include <stdio.h>  
86. int fgetpos(FILE *restrict fp, fpos_t *restrict pos);  
87. int fsetpos(FILE *fp, const fpos_t *pos);  
88.   
89.   
90. //格式化I/O  
91. //格式化输出  
92. #include <stdio.h>  
93. int printf(const char *restrict format, ...);  
94. int fprintf(FILE *restrict fp, const char *restrict format, ...);  //这三个函数执行成  
95. int dprintf(int fd, const char *restrict format, ...);  //功返回字符数，否则返回负数  
96. //若执行成功返回存入数组的字符数，否则返回负数  
97. int sprintf(char *restrict buf, const char *restrict format, ...);  
98. //若缓冲区足够大，返回将要存入数组的字符数，若编码出错返回负数  
99. int snprintf(char *restrict buf, size_t n, const char *restrict format, ...);  
100.   
101.   
102. //下面五种printf族的变体类似printf，但是可变参数替换成了arg  
103. #include <stdarg.h>  
104. #include <stdio.h>  
105. int vprintf(const char *restrict format, va_list arg);  
106. int vfprintf(FILE *restrict fp, const char *restrict format, va_list arg);  
107. int vdprintf(int fd, const char *restrict format, va_list arg);  
108. int vsprintf(char *restrict buf, const char *restrict format, va_list arg);  
109. int vsnprintf(char *restrict buf, size_t n, const char *restrict format, va_list arg);  
110.   
111.   
112. //格式化输入  
113. #include <stdio.h>  
114. int scanf(const char *restrict format, ...);  
115. int fscanf(FILE *restrict fp, const char *restrict format, ...);  
116. int sscanf(const char *restrict buf, const char *restrict format, ...);  
117.   
118. //与printf类似，scanf族也使用由<stdarg.h>说明的可变长度的参数表  
119. #include <stdarg.h>  
120. #include <stdio.h>  
121. int vscanf(const char *restrict format, va_list arg);  
122. int vfscanf(FILE *restrict fp, const char *restrict format, va_list arg);  
123. int vsscanf(const char *restrict buf, const char *restrict format, va_list arg);  
124.   
125.   
126. //可以对一个流调用fileno函数获得其描述符  
127. #include <stdio.h>  
128. int fileno(FILE *fp);  
129.   
130. //临时文件  
131. #include <stdio.h>  
132. char *tmpnam(char *ptr);  
133. FILE *tmpfile(void);  
134.   
135. //Single UNIX Specification为处理临时文件定义了另外两个函数  
136. #include <stdlib.h>  
137. char *mkdtemp(char *template);  
138. int mkstemp(char *template);  
139.   
140. //内存流，创建内存流  
141. #include <stdio.h>  
142. #include <wchar.h>  
143. FILE *fmemopen(void *restrict buf, size_t size, const char *restrict type);  
144. FILE *open_memstream(char **bufp, size_t *sizep);  
145. FILE *open)wmemstream(wchar_t **buf, size_t *sizep);  

 

 

标准I/O提供了以下三种类型缓冲:

1)全缓冲，在这种情况下，在填满标准I/O缓冲区后才进行实际I/O操作，对于驻留在磁盘上的文件上的文件

    通常都是由标准I/O库实施全缓冲的。在一个流上执行第一次I/O操作时，相关标准I/O函数通常调用malloc

    获得需要使用的缓冲区

2)行缓冲，在这种情况下当输入和输出中遇到换行符时，标准I/O库执行I/O操作。这允许我们一次输出一个

   字符，但只有在写了一行之后才进行实际I/O操作。当流涉及一个终端时，通过使用行缓冲。

3)不带缓冲，标准I/O库不对字符进行缓冲存储。列如用标准I/O函数fputs写15个字符到不带缓冲的流中，

   我们就期望这15个字符能立即输出

标准错误流stderr通常是不带缓冲的，这就是的出错信息可以尽快显示出来，而不管他们是否含有一个换行

  符

ISO C要求下列缓冲特征:

1)当且仅当标准输入和标准输出并不指向交互设备时，它们才是全缓冲的

2)标准错误绝不会是全缓冲的

这两个函数的动作，以及他们的各个选项

函数	mode	buf	缓冲区及长度	缓冲类型
setbuf		非空	长度为BUFSIZE的用户缓冲区buf	全缓冲或行缓冲
同上		NULL	无缓冲区	不带缓冲
setvbuf	_IOFBF	非空	长度为size的用户缓冲区buf	全缓冲
	_IOFBF		合适长度的系统缓冲区buf	全缓冲
	_IOLBF		长度为size的用户缓冲区buf	行缓冲
	_IOLBF		合适长度的系统缓冲区buf	行缓冲
同上	_IONBF		无缓冲区	不带缓冲

 

 

type参数指定对该I/O流的读，写方式，ISO C规定type参数可以有15种不同的值

type	说明	open(2)标志
r或rb	为读而打开	O_RDONLY
w或wb	把文件截断至0长，或为写而创建	O_WRONLY | O_CREAT | O_TRUNC
a或ab	追加，为在文件尾写而打开，或为写而创建	O_WRONLY | O_CREAT | O_APPEND
r+或r+b或rb+	为读和写而打开	O_RDWR
w+或w+b或wb+	把文件截断至0长，或为读和写打开	O_RDWR | O_CREAT | O_TRUNC
a+或a+b或ab+	为在文件尾读和写打开或创建	O_RDWR | O_CREAT | O_APPEND

 

 

打开一个流的6种方式

限制	R	W	a	r+	w+	a+
文件必须已存在	是			是
放弃文件以前的内容		是			是
流可以读	是			是	是	是
流可以写		是	是	是	是	是
流只可在尾端写			是			是

 

 

格式化输出，一个转换说明有4个可选部分

%[flags] [fldwidth] [percision] [lenmodifier] convtype

参数	说明
fldwidth	最小字段宽度。转换后参数字符数若小于宽度，则多余字符位用空格填充，字段宽度是一个 非负数十进制数，或是一个星号(*)
precision	整型转换后最少输出数字位数，浮点数转换后小数点后的最少位数，字符串转换后最大字节 数。精度是一个点(.) ，其后跟随一个可选的非负数十进制或一个星号(*) 宽度和精度字段两者皆可为*。此时一个整型参数指定宽度或精度的值。该整型参数正好位于 被转换的参数之前。
lenmodifier	参数长度
convtype	不可选的，它控制如何解释参数

 

各种标志如下

标志	说明
'	(撇号)将蒸熟按千位分组字符
-	在字段内左对齐输出
+	总是显示带符号转换的正负号
(空格)	如果第一个字符不是正负号，则在其前面加上一个空格
#	指定另一种转换形式(列如，对于十六进制格式，加上0x前缀)
0	添加前导0(而非空格)进行填充

 

lenmodifier说明参数长度

长度修饰符	说明
hh	将相应的参数按signed或unsigned char类型输出
h	将相应的参数按signed或unsigned short类型输出
l	将相应的参数按signed或unsigned long或宽字符类型输出
ll	将相应的参数按signed或unsigned long long类型输出
j	intmax_t或uintmax_t
z	size_t
t	ptrdiff_t
L	long double

convtype不是可选的，它控制如何解释参数

转换类型	说明
d，i	有符号十进制
o	无符号八进制
u	无符号是兼职
x，X	无符号十六进制
f，F	双精度浮点数
e，E	指数格式双精度浮点数
g，G	根据转换后的值解释为f，F，e或E
a，A	十六进制指数格式双精度浮点数
c	字符(若带长度修饰符l，为宽字符)
s	字符串(若带长度修饰符l，为宽字符)
P	指向void的指针
n	到目前为止，此printf调用输出的字符的数目将被写入到 指针所指向的带符号整型中
%	一个%字符
C	宽字符(XSI扩展，等效于lc)
S	宽字符串(XSI扩展，等效于ls)

 

 

 

格式化输入

一个转换说明有三个可选择部分，下面将他们都示于方括号中:

%[*] [fldwidth] [m] [lenmodifier] convtype

参数	说明
fldwidth	最大宽度(即最大字符数)
lenmodifier	要用转换结果赋值的参数大小
convtype	类似printf族的转换类型字段，差别是作为一种选项， 输入中带符号的可赋予无符号类型
m	在字段宽度和长度修饰符之间的可选项m是赋值分配符 可用于%c，%s，以及%[转换符]

 

转换说明中的转换类型

转换类型	说明
d	有符号十进制，基数为10
i	有符号十进制，基数由输入格式决定
O	无符号八进制(输入可选的有符号)
u	无符号十进制，基数为10(输入可选的有符号)
x，X	无符号十六进制(输入可选的有符号)
a，A，e，E f，F，g，G	浮点数
c	字符(若带长度修饰符l ，为宽字符)
s	字符串(若带长度修饰符l ，为宽字符串)
[	匹配列出的字符序列，以] 终止
]^	匹配除列出字符意外的所有字符，以]终止
P	指向void的指针
n	将到目前为止该函数调用读取的字符数写入到指针 所指向的无符号整型中
%	一个%符号
C	宽字符(XSI 扩展，等效于lc)
S	宽字符串(XSI 扩展，等效于ls)

 

 

内存流的type参数

type	说明
r 或 rb	为读而打开
w 或 wb	为写而打开
a 或 ab	追加，在为第一个null字节处写而打开
r+ 或 r+b 或 rb+	为读和写而打开
w+ 或 w+b 或 wb+	把文件截断至0长，为读和写而打开
a+ 或 a+b 或 ab+	追加，为在第一个null字节处读和谐而打开

 

这些取值对应于基于文件的标准I/O流的type参数取值，但其中还是有差别

1)无论何时以追加写方式打开内存流时，当前文件位置设置为缓冲区中第一个null字节，如果缓冲区中不

   存在null字节，则当前位置就设置为缓冲区结尾的后一个字节。当流并不是以追加方式打开时，当前

   位置设置为缓冲区的开始位置。因为追加写模式通过第一个null字节确定数据的尾端，内存流并不合适

   存储二进制数据

2)如果buf参数是一个null指针，打开流进行读或者写都没有任何意义。因为在这种情况下缓冲区通过

   fmemopen进行分配的，没有办法找到缓冲区的地址，只写方式打开流意味着无法读取已写入的数据，同样

   以读方式打开流意味着只能读取那些我们无法写入的缓冲区中的数据

3)任何时需要增加流缓冲区中数据量以及调用fclose，fflush，fseek，fseeko，以及fsetpos时都会在当前

   位置写入一个null

 

 

 

 

 

标准I/O读写单个字符的列子

1. #include <fcntl.h>    
2. #include <stdio.h>    
3. #include <unistd.h>    
4. #include <sys/stat.h>    
5. #include <stdio.h>  
6. int main(int argc, char *argv[]) {  
7.         FILE *file_r;  
8.         FILE *file_w;  
9.         char *path = "a.tar.gz";  
10.         char *dest = "tmp.tar.gz";  
11.         int num;  
12.   
13.         if((file_r=fopen(path,"r")) == NULL) {  
14.                 printf("fopen %s error\r\n",path);  
15.         }  
16.         if((file_w=fopen(dest,"w+")) ==NULL) {  
17.                 printf("fopen %s error\r\n",dest);  
18.         }  
19.   
20.         while( (num=getc(file_r)) != EOF ) {  
21.                 if(putc(num,file_w) == EOF) {  
22.                         printf("output error\r\n");  
23.                 }  
24.         }  
25.         if(ferror(file_r)) {  
26.                 printf("intpu error\r\n");  
27.         }  
28.   
29.         if(fclose(file_r)==EOF) {  
30.                 printf("fclose %s error\r\n",path);  
31.         }  
32.         if(fclose(file_w)==EOF) {  
33.                 printf("fclose %s error\r\n",dest);  
34.         }  
35.         return 0;  
36. }  

 

 

标准I/O读写(读写一行)

1. #include <fcntl.h>  
2. #include <stdio.h>  
3. #include <unistd.h>  
4. #include <sys/stat.h>  
5. #include <stdio.h>  
6. #define MAXLINE 10240  
7. int main(int argc, char *argv[]) {  
8.         char buf[MAXLINE];  
9.         FILE *file_r;  
10.         FILE *file_w;  
11.         char *src = "man.config";  
12.         char *dest = "buf.config";  
13.         int num;  
14.   
15.         if((file_r=fopen(src,"r")) == NULL) {  
16.                 printf("fopen %s error\r\n",src);  
17.         }  
18.         if((file_w=fopen(dest,"w+")) == NULL) {  
19.                 printf("fopen %s error\r\n",dest);  
20.         }  
21.   
22.         while(fgets(buf,MAXLINE,file_r) != NULL) {  
23.                 if(fputs(buf,file_w) == EOF) {  
24.                         printf("output error\r\n");  
25.                 }  
26.         }  
27.   
28.         if(ferror(file_r)) {  
29.                 printf("input error\r\n");  
30.         }  
31.         if(fclose(file_r) == EOF) {  
32.                 printf("fclose %s error\r\n",src);  
33.         }  
34.         if(fclose(file_w) == EOF) {  
35.                 printf("fclose %s error\r\n",dest);  
36.         }  
37.         return 0;  
38. }  

 

 

标准I/O读写二进制文件

1. #include <fcntl.h>  
2. #include <stdio.h>  
3. #include <unistd.h>  
4. #include <sys/stat.h>  
5. #include <stdio.h>  
6. int main(int argc, char *argv[]) {  
7.         FILE *file_r;  
8.         FILE *file_w;  
9.         char *src = "a.tar.gz";  
10.         char *dest = "binary.tar.gz";  
11.         char buf[1024];  
12.         int num;  
13.   
14.         file_r = fopen(src,"r");  
15.         file_w = fopen(dest,"w+");  
16.   
17.         while( (num=fread(buf,sizeof(char),1024,file_r)) > 0) {  
18.                 if(fwrite(buf,sizeof(char),num,file_w) != num) {  
19.                         printf("fwrite %s error\r\n",dest);  
20.                 }  
21.         }  
22.         if(ferror(file_r)) {  
23.                 printf("input error\r\n");  
24.         }  
25.         fclose(file_r);  
26.         fclose(file_w);  
27.         return 0;  
28. }  

 

 

测试三个标准流和一个普通文件的缓冲区信息

书中列子buffer_size()函数是返回 (fp->_bf._size)，但实际没有这个变量，所以只好改成-1

1. #include <fcntl.h>  
2. #include <stdio.h>  
3. #include <unistd.h>  
4. #include <sys/stat.h>  
5. #include <stdio.h>  
6. static int buffer_size(FILE *fp) {  
7.         return -1;  
8. }  
9.   
10. static int is_unbuffered(FILE *fp) {  
11.         return (fp->_flags & _IONBF);  
12. }  
13.   
14. static int is_linebuffered(FILE *fp) {  
15.         return (fp->_flags & _IOLBF);  
16. }  
17.   
18. static void pr_stdio(const char *name, FILE *fp) {  
19.         printf("stream = %s,  ",name);  
20.         if(is_unbuffered(fp)) {  
21.                 printf("unbuffered");  
22.         }  
23.         else if(is_linebuffered(fp)) {  
24.                 printf("line buffered");  
25.         }  
26.         else {  
27.                 printf("fully buffered");  
28.         }  
29.         printf(",buffer size = %d\n", buffer_size(fp));  
30. }  
31.   
32. int main(int argc, char *argv[]) {  
33.         FILE *fp;  
34.         fputs("enter ant character\n",stdout);  
35.         if(getchar() == EOF) {  
36.                 printf("getchar error\r\n");  
37.         }  
38.         fputs("one line to standard error\n",stderr);  
39.         pr_stdio("stdin",stdin);  
40.         pr_stdio("stdout",stdout);  
41.         pr_stdio("stderr",stderr);  
42.         if((fp=fopen("/etc/passwd","r")) == NULL) {  
43.                 printf("\r\nfopen error");  
44.         }  
45.         if(getc(fp) == EOF) {  
46.                 printf("getc error");  
47.         }  
48.         pr_stdio("/etc/passwd",fp);  
49.         return 0;  
50. }  

打印结果

1. enter ant character  
2.   
3. one line to standard error  
4. stream = stdin,  fully buffered,buffer size = -1  
5. stream = stdout,  fully buffered,buffer size = -1  
6. stream = stderr,  unbuffered,buffer size = -1  
7. stream = /etc/passwd,  fully buffered,buffer size = -1  

 

 

创建临时文件，gcc编译时会有一段警告

warning: the use of `tmpnam' is dangerous, better use `mkstemp'

1. #include <fcntl.h>  
2. #include <stdio.h>  
3. #include <unistd.h>  
4. #include <sys/stat.h>  
5. #include <stdio.h>  
6. #define MAXLINE 1024  
7. int main(int argc, char *argv[]) {  
8.         char name[L_tmpnam], line[MAXLINE];  
9.         FILE *fp;  
10.         printf("%s\n", tmpnam(NULL));  
11.         tmpnam(name);  
12.         printf("%s\n", name);  
13.   
14.         if((fp=tmpfile()) == NULL) {  
15.                 printf("tmpfile error\r\n");  
16.         }  
17.         fputs("one line of output\n",fp);  
18.         rewind(fp);  
19.         if(fgets(line,sizeof(line),fp) == NULL) {  
20.                 printf("fgets error\r\n");  
21.         }  
22.         fputs(line,stdout);  
23.         return 0;  
24. }  

 

 

第二种创建临时文件的方式

1. #include <fcntl.h>  
2. #include <stdio.h>  
3. #include <unistd.h>  
4. #include <sys/stat.h>  
5. #include <stdio.h>  
6. #include <errno.h>  
7. static void make_temp(char *template) {  
8.         int fd;  
9.         struct stat buf;  
10.         if((fd=mkstemp(template)) < 0) {  
11.                 printf("mkstemp create error\r\n");  
12.         }  
13.         printf("temp name = %s\n",template);  
14.         close(fd);  
15.         if(stat(template, &buf) < 0) {  
16.                 if(errno == ENOENT) {  
17.                         printf("file don't exist\n");  
18.                 }  
19.                 else {  
20.                         printf("stat failed\r\n");  
21.                 }  
22.         }  
23.         else {  
24.                 printf("file exists\r\n");  
25.         }  
26.         unlink(template);  
27. }  
28.   
29. int main(int argc, char *argv[]) {  
30.   
31.         char good_template[] = "/tmp/dirXXXXX";  
32.         char *bad_template = "/tmp/dirXXXXX";  
33.         printf("try to create first temp file...\n");  
34.         make_temp(good_template);  
35.         printf("try to create second temp file...\n");  
36.         make_temp(bad_template);  
37.         return 0;  
38. }  

 

 

内存流

1. #include <fcntl.h>  
2. #include <stdio.h>  
3. #include <unistd.h>  
4. #include <sys/stat.h>  
5. #include <stdio.h>  
6. #include <errno.h>  
7. #include <string.h>  
8. #define BSZ 48  
9. int main(int argc, char *argv[]) {  
10.         FILE *fp;  
11.         char buf[BSZ];  
12.         memset(buf,'a', BSZ-2);  
13.         buf[BSZ-2] = '\0';  
14.         buf[BSZ-1] = 'X';  
15.         if((fp=fmemopen(buf,BSZ,"w+")) == NULL) {  
16.                 printf("fmemopen error\r\n");  
17.         }  
18.         printf("initial buffer content: %s\n",buf);  
19.         fprintf(fp, "hello,world");  
20.         fflush(fp);  
21.         printf("after fflush: %s\n",buf);  
22.         printf("len of string in buf = %ld\n",(long)strlen(buf));  
23.   
24.         memset(buf,'b',BSZ-2);  
25.         buf[BSZ-2] = '\0';  
26.         buf[BSZ-1] = 'X';  
27.         fprintf(fp, "hello,world");  
28.         fseek(fp, 0, SEEK_SET);  
29.         printf("after fseek:%s\n",buf);  
30.         printf("len of string in buf = %ld\n", (long)strlen(buf));  
31.   
32.         memset(buf,'c', BSZ-2);  
33.         buf[BSZ-2] = '\0';  
34.         buf[BSZ-1] = 'X';  
35.         fprintf(fp, "hello world");  
36.         fclose(fp);  
37.         printf("after fclose: %s\n",buf);  
38.         printf("len of string in buf = %ld\n", (long)strlen(buf));  
39.         return 0;  
40. }  

 

 

 

 

 

 

 

参考

FILE结构体的定义

stdio.h

标准I/O替代软件SFIO(还有FIO)