5.1 Introduction
这章介绍的standard I/O都是ISOC标准的。用这些standard I/O可以不用考虑一些buffer allocation、I/O optimal-sized的细节，增加了易用性。但是也有一些问题。
5.2 Streams and FILE Objects
1. Chapter3中提到的I/O routines的核心是file descriptor；而在standard I/O背景下，相应的概念换成了stream。
2. standard I/O可以设置signle character和multi character的不同模式。
5.3 Standard Inpupt, Standard Output, and Standard Error
STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO 也在standard I/O中有定义。头文件在<stdio.h>中
5.4 Buffering
standard I/O中调用了read和write这样的calls。而standard I/O的设计目的，有一条就是尽量减小调用read和write的次数。
buffering的方式分为以下三种：
1. Fully buffered
把buffer写满了就往外输出。如果强制往外输出，可以调用fflush函数。
2. Line buffered
根绝是否出现newline character判断是否往外输出buffer的内容。
但是，有些时候Line buffered等不到newline character也会被动刷新输出：
（1）standard I/O留给Line buffer的容量写满了，等不到newline character出现就刷新输出。这个比较好理解，满了就输出了。
（2）当有来自unbuffered stream或line-buffered的input请求，会强制刷新输出。这个书上讲的没理解，具体看到例子再说。
3. Unbuffered
这个比较好理解，不用buffer直接输出。例子，一般的error stream都是unbuffered的方式。
另，介绍了一个函数fflush(FILE *fp) 当fp==NULL的时候，刷新全部的output stream。
5.5 Opening a Stream
记住俩函数：
fopen(const char *restrict pathname, const char *restrict type) (char *restrict意思是参数只能是受限制的字符串，这里只能是‘w‘,‘r‘这类的限制的几个字符串)
fclose(FILE *fp)
5.6 Reading and Writing a Stream
读单个字符的三个函数：
int getc(FILE *fp)
int fgetc(FILE *fp)
int getchar(void)
三个函数的返回值有如下几种情况：
（1）如果执行成功且没有到末尾，则返回next character
（2）如果执行到文件末尾了，则返回EOF
（3）如果出错了，则返回error
书上关于返回值有这样的陈述“These three functions return the next character as an unsigned char converted to an int”。
读的是字符为什么返回值要采用整数的形式？
因为，可以区分正常字符、文件末尾、出错三种情况。如果是正常字符，转换成int后都是正的；如果是EOF和error则都是负的。
有的系统上EOF和error都是-1，那么还怎么区分是出错了还是读到文件末尾了呢？
还有以下两个函数，判断到底是error为真，还是eof为真：
int ferror(FILE *fp)
int feof(FILE *fp)
如果是真的，则返回非零；否则，返回零。
5.7 Line-at-a-Time
char *fgets(char *restrict buf, int n, FILE *restrict fp)
一次读一行，最多读n-1个字符；超过n-1个字符的部分就被抹掉了。n-1的原因是buffer必须是以null结束的
int fputs(const char*restrict str, FILE *restrict fp)
注意是否用补上换行符。
5.8 Standard I/O Efficiency
比较两种读写模式的效率，读一个500M大小的文件，然后在写到同样的文件中；比较这一读一写的效率。
代码1：
1 #include "apue.h"
2
3 int main()
4 {
5 int c;
6 while ((c=getc(stdin))!=EOF)
7 if (putc(c, stdout)==EOF)
8 err_sys("output error");
9 if (ferror(stdin))
10 err_sys("input error");
11 exit(0);
12 }
执行耗时如下：
代码2：
1 int main()
2 {
3 char buf[MAXLINE];
4 while (fgets(buf, MAXLINE, stdin)!=NULL)
5 {
6 if (fputs(buf,stdout)==EOF) {
7 err_sys("output error");
8 }
9 }
10
11 if (ferror(stdin)) {
12 err_sys("input error");
13 }
14 exit(0);
15 }
执行耗时如下：
代码1是逐个读字符，代码2是逐行读字符。对比二者执行结果，可以获得以下的结论：
（1）对比二者的耗时，发现system time都差不多：这意味着kernel耗时都差不多。
（2）差别在于user time不一样：原因就在于fgetc fputc读写同样的字符串需要调用的系统read write次数多；而fgets fputs调用的read write次数少很多，所以real time上体现了效率提高了。
5.9 Binary I/O
size_t fread(void *restrict ptr, size_t size, size_t nobj, FILE *restrict fp)
size_t fwrite(const void *restrict ptr, size_t size, size_t nobj, FILE *restrict fp)
每次读写一个完整的数据结构：struct int float这样的内容。
这样binary I/O的关键就在于这样一个完整的数据结构占多少byte。
书上提醒，完整的数据结构到底占多少byte跟编译器complier有关，还跟不同的机器架构有关，即提醒此处可能有坑。
5.10 Positioning a Stream
long ftell(FILE *fp) ：返回current file position indicator if OK, -1L on error
int fseek(FILE *fp, long offset, int whence) ：操作stream；通过whence参数控制操作的方式；成功返回0，出错返回-1
void rewind(FILE *fp)： stream移动到文件的beginning
类比Chapter3.6提出来的lseek()函数，lseek这个函数集成的功能比较多，可以直接得到fd对应的offset位置；而fseek由于只能返回01，因此需要单拎出来ftell这个函数来返回stream的当前位置
书上还介绍了两个ISO C standard的函数:
int fgetpos(FILE *restrict fp, fpos_t *restrict pos)
int fsetpos(FILE *fp, const fpos_t *pos)
书上对这两个函数给出的tips是便于porting to non-Unix systems （便于移植）
5.11 Formatted I/O
printf和scanf函数，用到再细看
5.12 Implementation Details
1. 给出了Unix System中，standard I/O最终还是调用了Chapter3中介绍的各种I/O routine来完成的。因此，每个standard I/O stream必然对应一个file descriptor。靠int fileno(FILE *fp)来实现这个功能。
2. 给出了一个简易的buffering three standard stream的实现，具体如下：
#include "apue.h"
void pr_stdio(const char *, FILE *);
int is_unbuffered(FILE *);
int is_linebuffered(FILE *);
int buffer_size(FILE *);
int main()
{
FILE *fp;
fputs("enter any character\n", stdout);
if(getchar()==EOF)
err_sys("getchar error");
fputs("one line to standard error\n",stderr);
pr_stdio("stdin", stdin);
pr_stdio("stdout", stdout);
pr_stdio("stderr", stderr);
if ((fp=fopen("/etc/passwd","r"))==NULL) {
err_sys("fopen error");
}
if (getc(fp)==EOF)
err_sys("getc error");
pr_stdio("/etc/passwd",fp);
exit(0);
}
void pr_stdio(const char *name, FILE *fp)
{
printf("stream = %s, ", name);
if (is_unbuffered(fp)) {
printf("unbuffered");
}
else if (is_linebuffered(fp)) {
printf("line buffered");
}
else
printf("fully buffered");
printf(", buffer size = %d\n", buffer_size(fp));
}
#if defined(_IO_UNBUFFERED)
int is_unbuffered(FILE *fp)
{
return(fp->_flags & _IO_UNBUFFERED);
}
int is_linebuffered(FILE *fp)
{
return(fp->_flags & _IO_LINE_BUF);
}
int buffer_size(FILE *fp)
{
return(fp->_IO_buf_end - fp->_IO_buf_base);
}
#elif defined(__SNBF)
int is_unbuffered(FILE *fp)
{
return(fp->_flags & __SNBF);
}
int is_linebuffered(FILE *fp)
{
return(fp->_flags & __SLBF);
}
int buffer_size(FILE *fp)
{
return(fp->_bf.size);
}
#elif defined(_IONBF)
#ifdef _LP64
#define _flag __pad[4]
#define _flag __pad[1]
#define _base __pad[2]
#endif
int is_unbuffered(FILE *fp)
{
return(fp->_flags & _IONBF);
}
int is_linebuffered(FILE *fp)
{
return(fp->_flags & _IOLBF);
}
int buffer_size(FILE *fp)
{
#ifdef _LP64
return(fp->_base - fp->_ptr);
#else
return(BUFSIZ);
#endif
}
#else
#error unknown stdio implementation
#endif
执行这个代码，结果如下：
（1）如果输入输出都是终端，则系统给出的buffer策略是line buffered
（2）如果输入输出都是文件，则系统给出的buffer策略是fully buffered
（3）如果是error输出，则默认是unbuffered策略
5.13 Temporary Files
1. 给了char *tmpnam(char *ptr) 和 FILE *tmpfile(void)的例子，使用方法。
#include <stdio.h>
#include <stdlib.h>
#define MAXLINE 4096
int main()
{
char name[L_tmpnam], line[MAXLINE];
FILE *fp;
printf("%s\n", tmpnam(NULL));
tmpnam(name);
printf("%s\n",name);
fp = tmpfile();
fputs("one line of output\n",fp);
rewind(fp);
fgets(line, sizeof(line), fp);
fputs(line, stdout);
exit(0);
}
代码执行结果如下：
（1）前两个printf是讲tmpnam的用法，作用是生成个独一无二的文件名；并展示了参数是NULL和不是NULL都是怎么个用法。
（2）后面一段是先用tmpfile()生成一个临时文件，向文件中写一行，再把写进去的内容读出来输出到终端。这样证明确实产生了临时文件，并且随着程序结束，临时文件也没有了。
2. 介绍了更为安全的两个临时文件函数char *mkdtemp(char *template) 和 int mkstemp(char *template)
从紧上面1的代码执行结果中可以看到有个关于tmpnam的warning。这个warning的原因是什么呢？
tmpnam函数有个弊端：tmpnam产生独一无二的临时文件名并不是一个原子操作；可能有个time window，tmpnam产生文件名A的同时，另一个应用产生相同文件名的文件了。
因此，就需要引出mkstemp这样的函数，保证是原子操作，即函数产生的文件名是独一无二的。
首先得明确一下临时文件的产生过程：1. 生成一个独一无二的临时文件名 2.马上unlink了
为什么要这么做呢？kernel判断一个file是否可以被delete主要取决于两点：
1. link数是0了
2. 没有process在使用这个file
因此，按照上述临时文件的原理，先生成文件名，然后unlink，则等着当前的process结束，或放弃对file的占用，kernel就把file给delete了。
这里需要注意的是，unlink这个操作需要我们自己来完成。
看个例子：
1 #include "apue.h"
2 #include <errno.h>
3
4 void make_temp(char *template)
5 {
6 int fd;
7 struct stat sbuf;
8
9 if ((fd = mkstemp(template))<0) {
10 err_sys("can‘t create temp file");
11 }
12 printf("temp name = %s\n", template);
13 close(fd);
14
15 if (stat(template,&sbuf)<0) {
16 if(errno==ENOENT)
17 printf("file doesn‘t exist\n");
18 else
19 err_sys("stat failed");
20 }
21 else
22 {
23 printf("file exists\n");
24 unlink(template);
25 }
26 }
27
28 int main()
29 {
30 char good_template[] = "/tmp/dirXXXXXX";
31 char *bad_template = "/tmp/dirXXXXXX";
32
33 printf("tring to crate first temp file..\n");
34 make_temp(good_template);
35 printf("trying to create second temp file...\n");
36 make_temp(bad_template);
37 exit(0);
38 }
代码执行结果如下：
从这段代码中可以看到，临时文件确实是存在的（“file exists”可以说明），并且需要我们手工unlink。
这里还涉及到一个细节，常量字符串不能修改，如果把常量字符串送到mkstemp函数中，会报段错误。因为，常量字符串在只读segment上面，mkstemp函数要修改这个常量字符串就会报错。
5.14 Memory Streams
这个部分说的是：是否可以像读写文件一样操作内存中的一块区域。下面这个函数就帮助user实现了这样的功能。
FILE *fmemopen(void *restrict buf, size_t size, const char *restrict type)
直接看一段代码：
1 #include "apue.h"
2
3 #define BSZ 48
4
5 int pr_print(char buf[])
6 {
7 int i;
8 for ( i=0; i<BSZ; ++i) printf("%c",buf[i]==‘\0‘?‘#‘:buf[i]);
9 printf("\n");
10 }
11
12 int pr_offset(FILE *fp)
13 {
14 printf(" memeory stream offset: %ld\n",ftell(fp));
15 }
16
17 int main()
18 {
19 FILE *fp;
20 char buf[BSZ];
21
22 memset(buf, ‘a‘, BSZ-2);
23 buf[BSZ-2]=‘\0‘;
24 buf[BSZ-1] = ‘X‘;
25 printf("befor fmemopen initial buffer contents: ");pr_print(buf);
26 fp = fmemopen(buf, BSZ, "w+");
27 pr_offset(fp);
28 printf("after fmemopen initial buffer contents: ");pr_print(buf);
29 fprintf(fp, "hello, world"); /*此时fp标志在buf的起始位置*/
30 //pr_offset(fp);
31 printf("before flush: %s\n",buf);
32 fflush(fp);
33 printf("after fflush:");
34 pr_print(buf); /*本来buf的内容是aaaa...\0#,但是由于fprintf的操作hello world写到前面buf的前面几个位置,并且后面跟了一个\0*/
35 pr_offset(fp);
36 printf("len of string in buf = %ld\n", (long)strlen(buf));
37
38 memset(buf, ‘b‘, BSZ-2);
39 buf[BSZ-2] = ‘\0‘;
40 buf[BSZ-1] = ‘X‘;
41 fprintf(fp, "hello, world");
42 pr_offset(fp);
43 fseek(fp, 0, SEEK_SET);
44 printf("after fseek:");
45 pr_offset(fp);
46 pr_print(buf);
47 printf("len of string in buf = %ld\n", (long)strlen(buf));
48
49 memset(buf, ‘c‘, BSZ-2);
50 buf[BSZ-2] = ‘\0‘;
51 buf[BSZ-1] = ‘X‘;
52 fprintf(fp, "hello, world");
53 fclose(fp);
54 printf("after fclose:");
55 pr_print(buf);
56 printf("len of string in buf = %ld\n", (long)strlen(buf));
57
58 return(0);
59 }
代码执行结果如下：
上述代码在书上5.15的例子基础上做了修改，原因是更好的理解各种操作对实际内存数据的影响。
这里有个点需要明确：printf函数在输出内存中字符串的时候，如何判断字符串结束了？首次遇见‘\0‘就认为字符串结束了。
下面按照执行顺序来分析为：
1. memset()之后，以buf为起始地址的内存字符串都被赋值为‘a‘了。
2. 执行fmemopen，将buf以w+的方式关联到一个FILE *类型变量fp上。这个时候，看书上P171的阐述，以‘w+’这种方式打开的时候，""truncate to 0 length and open for writing"。
（1）为了验证书上这句话，我调用了DIY的函数pr_offset，来查看此时current file position（具体ftell函数，可以参考书上P158），stream offset确实是0。
（2）那么stream offset是0意味着什么呢？我调用了DIY的函数pr_print函数，逐个输出buf开始的BSZ个字符：发现原来的首个字符‘a‘变成了‘\0‘，客观上在我实验的环境中就是这样。
3. 执行fprintf函数，向fp指向的buf写“hello, world”12个byte。但是这个写并不会马上写进去：
（1）执行fflush之前，buf的首个字符还是‘\0‘，因此用printf函数输出buf，自然什么都不会输出。
（2）执行fflush之后，fp的内容被写进去了；调用pr_print函数可以看到"hello, world"被写进去了，并且紧接着还写进去了一个‘\0‘；此时fp的offset变成了12，而且用strlen函数去统计buf的长度也是12。由此可见fprintf的工作方式，而且可以看到strlen的实现也差不多是根据第一个遇见的‘\0‘来统计字符串长度的。
4. 现在另起炉灶，把buf后面的BSZ长度的字符都设成‘b‘了。
（1）还是调用fprintf往fp里面再写一次“hello, world”；注意，此时fp的offset是12，跟执行memset没有关系，此时执行过第二次写“hello, world”之后，fp的offset变成了24。
（2）此时，执行fseek，将fp的offset移动到0，并用pr_offset函数验证。
（3）再次输出buf起始的BSZ个字符，发现“hello, world"确实从第13个位置写到了第24个位置，并且在末尾跟上了一个‘\0‘，验证了上面的分析。
5. 再次处理一下，把buf后面的BSZ长度的字符都设成‘c‘了。
（1）先明确一点，此时fp的offset虽然恢复0了，但是fp关联的memory stream的amount of data还是24个字符，这一点比较关键。
（2）此时还是fprintf往fp里面写"hello, world"12个字符，随后把fp关掉。
（3）此时，再用pr_print逐个输出buf起始的BSZ个字符，发现了一个与之前不同的地方，即"hello, world"的后面没有在跟着一个‘\0‘。回想（1）中提到的，此时fp关联的memory steam的amount还是48，如果从0开始写12个byte，并不会改变整个memory stream的amount，因此后面就没有再跟着‘\0‘了，这也就解释了最后的一组输出。
6. 如果我们将上述代码的30行的屏蔽符号去掉，在执行代码，会得到以下结果：
这里只需要注意before flush后面的输出即可：为什么没有用fflush，还是刷出来了buf呢？
我猜，这是因为ftell(fp)中有刷新fp的操作，所以相当于隐藏着调用了一个fflush了。
这个memory streams一开始看的并不清晰，主要是不明确printf的实现原理，遇到‘\0‘不输出后面的type了。所以，掌握这些基础函数的原理对提高工作效率比较有帮助。