第一部分标准IO及文件IO（第2章文件I/O）

2.1文件I/O与标准文件I/O

2.1.1文件I/O和标准I/O的概念

文件I/O：文件I/O称之为不带缓存的IO（unbuffered I/O)。不带缓存指的是每个read，write都调用内核中的一个系统调用。也就是一般所说的低级I/O——操作系统提供的基本IO服务，与os绑定，特定于linix或unix平台。
标准I/O：标准I/O是ANSI C建立的一个标准I/O模型，是一个标准函数包和stdio.h头文件中的定义，具有一定的可移植性。标准I/O库处理很多细节。例如缓存分配，以优化长度执行I/O等。标准的I/O提供了三种类型的缓存。
全缓存：当填满标准I/O缓存后才进行实际的I/O操作。
行缓存：当输入或输出中遇到新行符时，标准I/O库执行I/O操作。
不带缓存：stderr就是了。

2.1.2文件I/O和标准I/O的区别

文件I/O 又称为低级磁盘I/O，遵循POSIX相关标准。任何兼容POSIX标准的操作系统上都支持文件I/O。标准I/O被称为高级磁盘I/O，遵循ANSI C相关标准。只要开发环境中有标准I/O库，标准I/O就可以使用。（Linux 中使用的是GLIBC，它是标准C库的超集。不仅包含ANSI C中定义的函数，还包括POSIX标准中定义的函数。因此，Linux 下既可以使用标准I/O，也可以使用文件I/O）。
通过文件I/O读写文件时，每次操作都会执行相关系统调用。这样处理的好处是直接读写实际文件，坏处是频繁的系统调用会增加系统开销，标准I/O可以看成是在文件I/O的基础上封装了缓冲机制。先读写缓冲区，必要时再访问实际文件，从而减少了系统调用的次数。
文件I/O中用文件描述符表现一个打开的文件，可以访问不同类型的文件如普通文件、设备文件和管道文件等。而标准I/O中用FILE（流）表示一个打开的文件，通常只用来访问普通文件。

2.1.3各自使用的函数

表1

1.fopen与open
标准I/O使用fopen函数打开一个文件：

FILE* fp=fopen(const char* path,const char *mod)

其中path是文件名，mod用于指定文件打开的模式的字符串，比如”r”,”w”,”w+”,”a”等等，可以加上字母b用以指定以二进制模式打开（对于 *nix系统，只有一种文件类型，因此没有区别）,如果成功打开，返回一个FILE文件指针，如果失败返回NULL,这里的文件指针并不是指向实际的文件，而是一个关于文件信息的数据包，其中包括文件使用的缓冲区信息。
文件IO使用open函数用于打开一个文件：

int fd=open(char *name,int how);

与fopen类似，name表示文件名字符串，而how指定打开的模式：O_RDONLY(只读),O_WRONLY(只写）,O_RDWR （可读可写),还有其他模式请man 2 open。成功返回一个正整数称为文件描述符，这与标准I/O显著不同，失败的话返回-1，与标准I/O返回NULL也是不同的。
2.fclose与close
与打开文件相对的，标准I/O使用fclose关闭文件，将文件指针传入即可，如果成功关闭，返回0，否则返回EOF。
比如：

if(fclose(fp)!=0)  
     printf("Error in closing file");

而文件IO使用close用于关闭open打开的文件，与fclose类似，只不过当错误发生时返回的是-1，而不是EOF，成功关闭同样是返回0。C语言用error code来进行错误处理的传统做法。
3. 读文件，getc,fscanf,fgets和read
标准I/O中进行文件读取可以使用getc，一个字符一个字符的读取，也可以使用gets（读取标准io读入的）、fgets以字符串单位进行读取（读到遇到的第一个换行字符的后面），gets（接受一个参数，文件指针）不判断目标数组是否能够容纳读入的字符，可能导致存储溢出(不建议使用），而fgets使用三个参数：

char * fgets(char *s, int size, FILE *stream);

第一个参数和gets一样，用于存储输入的地址，
第二个参数为整数，表示输入字符串的最大长度，
最后一个参数就是文件指针，指向要读取的文件。最后是fscanf，与scanf类似，只不过增加了一个参数用于指定操作的文件，比如fscanf(fp,”%s”,words)
文件IO中使用read函数用于读取open函数打开的文件，函数原型如下：

ssize_t numread=read(int fd,void *buf,size_t qty);

其中fd就是open返回的文件描述符，buf用于存储数据的目的缓冲区，而qty指定要读取的字节数。如果成功读取，就返回读取的字节数目（小于等于qty）
4. 判断文件结尾
如果尝试读取达到文件结尾，标准IO的getc会返回特殊值EOF，而fgets碰到EOF会返回NULL,而对于*nix的read函数，情况有所不同。read读取qty指定的字节数，最终读取的数据可能没有你所要求的那么多（qty），而当读到结尾再要读的话，read函数将返回0。
5. 写文件：putc,fputs,fprintf和write
与读文件相对应的，标准C语言I/O使用putc写入字符，比如：

putc(ch,fp);

第一个参数是字符，
第二个是文件指针。而fputs与此类似：

fputs(buf,fp);

仅仅是第一个参数换成了字符串地址。而fprintf与printf类似，增加了一个参数用于指定写入的文件，比如：

fprintf(stdout,"Hello %s.\n","dennis");

切记fscanf和fprintf将FILE指针作为第一个参数，而putc,fputs则是作为第二个参数。
在文件IO中提供write函数用于写入文件，原型与read类似：

ssize_t result=write(int fd,void *buf ,size_t amt);

fd是文件描述符，buf是将要写入的内存数据，amt是要写的字节数。如果写入成功返回写入的字节数，通过result与amt的比较可以判断是否写入正常，如果写入失败返回-1。
6. 随机存取：fseek()、ftell()和lseek()
标准I/O使用fseek和ftell用于文件的随机存取，先看看fseek函数原型

int fseek(FILE *stream, long offset, int whence);

第一个参数是文件指针;
第二个参数是一个long类型的偏移量（offset），表示从起始点开始移动的距离;
第三个参数就是用于指定起始点的模式，stdio.h指定了下列模式常量：
SEEK_SET 文件开始处
SEEK_CUR 当前位置
SEEK_END 文件结尾处
看几个调用例子：

 fseek(fp,0L,SEEK_SET); //找到文件的开始处 
 fseek(fp,0L,SEEK_END); //定位到文件结尾处 
 fseek(fp,2L,SEEK_CUR); //文件当前位置向前移动2个字节数

而ftell函数用于返回文件的当前位置，返回类型是一个long类型，比如下面的调用：

fseek(fp,0L,SEEK_END);//定位到结尾 
long last=ftell(fp); //返回当前位置

那么此时的last就是文件指针fp指向的文件的字节数。
与标准I/O类似，*nix系统提供了lseek来完成fseek的功能，原型如下：

off_t lseek(int fildes, off_t offset, int whence);

fildes是文件描述符，而offset也是偏移量，whence同样是指定起始点模式，唯一的不同是lseek有返回值，如果成功就返回指针变化前的位置，否则返回-1。whence的取值与fseek相同：SEEK_SET,SEEK_CUR,SEEK_END，但也可以用整数 0,1,2相应代替。

2.1.4系统调用与库函数

上面我们一直在讨论文件I/O与标准I/O的区别，其实可以这样说，文件I/O是系统调用、标准I/O是库函数，看下面这张图：

图1
POSIX：Portable Operating System Interface 可移植操作系统接口
ANSI：American National Standrads Institute 美国国家标准学会
1、系统调用
操作系统负责管理和分配所有的计算机资源。为了更好地服务于应用程序，操作系统提供了一组特殊接口——系统调用。通过这组接口用户程序可以使用操作系统内核提供的各种功能。例如分配内存、创建进程、实现进程之间的通信等。
为什么不允许程序直接访问计算机资源？答案是不安全。单片机开发中，由于不需要操作系统，所以开发人员可以编写代码直接访问硬件。而在32位嵌入式系统中通常都要运行操作系统，所以开发人员可以编写代码直接访问硬件。而在32位嵌入式系统中通常都要运行操作系统，程序访问资源的方式都发生了改变。操作系统基本上都支持多任务，即同时可以运行多个程序。如果允许程序直接访问系统资源，肯定会带来很多问题。因此，所有软硬件资源的管理和分配都有操作系统负责。程序要获取资源（如分配内存，读写串口）必须由操作系统来完成，即用户程序向操作系统发出服务请求，操作系统收到请求后执行相关的代码来处理。
用户程序向操作系统提出请求的接口就是系统调用。所有的操作系统都会提供系统调用接口，只不过不同的操作系统提供的系统调用接口各不相同。Linux 系统调用接口非常精简，它继承了Unix 系统调用中最基本的和最有用的部分。这些系统调用按照功能大致可分为进程控制、进程间通信、文件系统控制、存储管理、网络管理、套接字控制、用户管理等几类。
2、库函数
库函数可以说是对系统调用的一种封装，因为系统调用是面对的是操作系统，系统包括Linux、Windows等，如果直接系统调用，会影响程序的移植性，所以这里使用了库函数，比如说C库，这样只要系统中安装了C库，就都可以使用这些函数，比如printf() scanf()等，C库相当于对系统函数进行了翻译，使我们的APP可以调用这些函数。
3、用户编程接口API
前面提到利用系统调用接口程序可以访问各种资源，但在实际开发中程序并不直接使用系统调用接口，而是使用用户编程接口（API）。为什么不直接使用系统调用接口呢？
原因如下：
1）系统调用接口功能非常简单，无法满足程序的需求。
2）不同操作系统的系统调用接口不兼容，程序移植时工作量大。
用户编程接口通俗的解释就是各种库（最重要的就是C库）中的函数。为了提高开发效率，C库中实现了很多函数。这些函数实现了常用的功能，供程序员调用。这样一来，程序员不需要自己编写这些代码，直接调用库函数就可以实现基本功能，提高了代码的复用率。使用用户编程接口还有一个好处：程序具有良好的可移植性。几乎所有的操作系统上都实现了C库，所以程序通常只需要重新编译一下就可以在其他操作系统下运行。
用户编程接口（API）在实现时，通常都要依赖系统调用接口。例如，创建进程的API函数fork()对应于内核空间的sys_fork()系统调用。很多API函数通过多个系统调用来完成其功能。还有一些API函数不要调用任何系统调用。
在Linux 中用户编程接口（API）遵循了在Unix中最流行的应用编程界面标准——POSIX标准。POSIX标准是由IEEE和ISO/IEC共同开发的标准系统。该标准基于当时想用的Unix 实践和经验，描述了操作系统的系统调用编程接口（实际上就是API），用于保证应用程序可以在源代码一级商多种操作系统上运行。这些系统调用编程接口主要是通过C库（libc )实现的。
第一部分标准IO及文件IO（第2章文件I/O）

图2 系统调用、API及系统命令之间的关系

2.2文件I/O

Linux操作系统是基于文件概念的。文件是以字符序列构成的信息载体。根据这一点，可以把I/O设备当做文件来处理，因此，在磁盘上的普通文件进行交互所用的统一系统调用可以直接用于I/O设备。这样大大简化了系统对于不同设备的处理，提高了效率。Linux中的文件主要分为6种：普通文件、目录文件、符号链接文件、管道文件、套接字文件和设备文件。
那么，内核如何区分和引用特定的文件呢？这里用到了一个重要的概念——文件描述符。对于Linux而言，所有的设备和文件的操作都是通过文件描述符来进行的。文件描述符是一个非负的整数，它是一个索引值，并指向在内核中每个进程打开文件的记录表。当打开一个现存文件或创建一个新文件时，内核就向进程返回一个文件描述符；读写文件时，需要把文件描述符作为参数传递给相应的函数。
通常，一个进程启动时，都会打开3个流：标准输入、标准输出和标准错误。这3个流分别对应文件描述符0、1 和 2（对应的宏分别是STDIN_FILENO、STDOUT_FILENO和STDERR_FILENO）。
基于文件描述符的I/O操作虽然不能直接移植到类Linux以外的系统上去（如Windows），但它往往是实现某些I/O操作的唯一途径，如Linux中底层文件操作函数、多路I/O、TCP/IP套接字编程接口等。同时，他们也很好地兼容POSIX标准，因此，可以很方便地移植到任何POSIX平台上。基于文件描述符的I/O操作是Linux中最常用的操作之一。
文件I/O相关函数：open() 、read() 、write() 、lseek() 和close() 。这些函数的特点是不带缓冲，直接对文件（包括设备）进行读写操作。这些函数不是ANSI C的组成部分，而是POSIX相关标准来定义。

2.2.1文件打开与和关闭

open()函数用于创建或打开文件，在打开或创建文件时可以指定文件打开方式及文件的访问权限。

表2 open()函数
第一部分标准IO及文件IO（第2章文件I/O）

close()函数用于关闭一个被打开的文件。当一个进程终止时，所有打开的文件都有内核自动关闭。很多程序都利用这一特性而不显示地关闭一个文件。
表3 close()函数
第一部分标准IO及文件IO（第2章文件I/O）

2.2.2文件读写

read()函数从文件中读取数据存放到缓冲区中，并返回实际读取的字节数。若返回0，则表示没有数据可读，即已达到文件尾。读操作从文件的当前读写位置开始读取数据，当前读写位置自动往后移动。

表4 read()函数
第一部分标准IO及文件IO（第2章文件I/O）

在读到普通文件时，若读到要求的字节数之前已到达问价你的尾部，则返回的字节数会小于指定读出的字节数；
write()函数将数据写入文件中，并返回实际写入的字节数。写操作从文件的当前读写位置开始写入。对磁盘文件进行写操作时，若磁盘已满，write()函数返回失败；
表5 write()函数
第一部分标准IO及文件IO（第2章文件I/O）

下面写个简单小程序，实现copy程序，完成文件的复制，代码如下：
【参见附件/copy.c】

#include <stdio.h> 
#include <unistd.h> 
#include <sys/types.h> 
#include <fcntl.h> 
#include <sys/stat.h> 
#define maxsize 256 
int main(int argc, char *argv[])  
{  
    int fd1,fd2;  
    int byte;  
    char buffer[maxsize];  
    if(argc != 3)  
    {  
printf("command error!\n");  
return -1;  
    }    
    if((fd1 = open(argv[1],O_RDONLY)) == -1)  
    {  
            perror("open fails");  
return -1;  
    }  
  //如果文件不存在，则创建，若存在，则覆盖； 
    if((fd2 = open(argv[2],O_WRONLY | O_CREAT | O_TRUNC ,0664)) == -1)
    {  
perror("open fails");  
return -1;  
    }  
    while(1)  
    {  
if((byte = read(fd1,buffer,maxsize)) > 0)  
write(fd2,buffer,byte);  
            if(byte == 0)  
                    break; //如果读不到数据，则返回 
    }  
    close(fd1);  
    close(fd2);  
    return 0;  
}

执行结果如下：
第一部分标准IO及文件IO（第2章文件I/O）
我们可以看到，原来file2.c并不存在，执行完程序后，file2.c存在，且大小和file1.c相同。

2.2.3文件定位

lseek()函数对文件当前读写位置进行定位。它只能对可定位（可随机访问）文件操作。管道、套接字和大部分字符设备文件不支持此类操作；

表6 lseek()函数
第一部分标准IO及文件IO（第2章文件I/O）

我们可以通过lseek函数实现一个小功能：查看文件的大小，代码如下：
【参见附件/lseek.c】

#include <stdio.h> 
#include <unistd.h> 
#include <fcntl.h> 
#include <sys/stat.h> 
#include <sys/types.h> 
int main(int argc, const char *argv[])  
{  
    int fd;  
    int length;  
    if(argc != 2)  
    {  
        printf("command error!\n");  
        return -1;  
    }  
    if((fd = open(argv[1],O_RDONLY)) == -1)  
    {  
        perror("open fails");  
        return -1;  
    }  
    length = lseek(fd,0,SEEK_END);  
    printf("The length of %s is %d bytes!\n",argv[1],length); 
    return 0;  
}

执行结果如下：
第一部分标准IO及文件IO（第2章文件I/O）
我们可以看到，得到了lseek.c正确大小！

2.3标准I/O

2.3.1标准I/O的由来

标准I/O指的是ANSI C 中定义的用于I/O操作的一系列函数。
只要操作系统安装了C库，标准I/O函数就可以调用。换句话说，如果程序中使用的是标准I/O函数，那么源代码不需要任何修改就可以在其他操作系统下编译运行，具有更好的可移植性。
除此之外，使用标准I/O可以减少系统调用的次数，提高系统效率。标准I/O函数在执行时也会用到系统调用。在执行系统调用时，Linux必须从用户态切换到内核态，处理相应的请求，然后再返回到用户态。如果频繁的执行系统调用会增加系统的开销。为避免这种情况，标准I/O在使用时为用户控件创建缓冲区，读写时先操作缓冲区，在合适的时机再通过系统调用访问实际的文件，从而减少了使用系统调用的次数。

2.3.2流的含义

标准I/O的核心对象就是流。当用标准I/O打开一个文件时，就会创建一个FILE结构体描述该文件（或者理解为创建一个FILE结构体和实际打开的文件关联起来）。我们把这个FILE结构体形象的称为流，我们在stdio.h里可以看到这个FILE结构体。
typedef struct {
short level; /* fill/empty level of buffer */
unsigned flags; /* File status flags */
char fd; /* File descriptor */
unsigned char hold; /* Ungetc char if no buffer */
short bsize; /* Buffer size */
unsigned char buffer; / Data transfer buffer */
unsigned char curp; / Current active pointer */
unsigned istemp; /* Temporary file indicator */
short token; /* Used for validity checking */
} FILE; /* This is the FILE object */
这个结构体：1）对 fd 进行了封装；2）对缓存进行了封装 unsigned char *buffer; 这而指向了buffer 的地址，实际这块buffer是cache,我们要将其与用户控件的buffer分开。
标准I/O函数都是基于流的各种操作，标准I/O中的流的缓冲类型有下面三种：
全缓冲。
在这种情况下,实际的I/O操作只有在缓冲区被填满了之后才会进行。对驻留在磁盘上的文件的操作一般是有标准I/O库提供全缓冲。缓冲区一般是在第一次对流进行I/O操作时,由标准I/O函数调用malloc函数分配得到的。
术语flush描述了标准I/O缓冲的写操作。缓冲区可以由标准I/O函数自动flush(例如缓冲区满的时候);或者我们对流调用fflush函数。
行缓冲
在这种情况下,只有在输入/输出中遇到换行符的时候,才会执行实际的I/O操作。这允许我们一次写一个字符,但是只有在写完一行之后才做I/O操作。一般的,涉及到终端的流–例如标注输入(stdin)和标准输出(stdout)–是行缓冲的。
无缓冲
标准I/O库不缓存字符。需要注意的是,标准库不缓存并不意味着操作系统或者设备驱动不缓存。
标准I/O函数时库函数，是对系统调用的封装，所以我们的标准I/O函数其实都是基于文件I/O函数的，是对文件I/O函数的封装，下面具体介绍·标准I/O最常用的函数。

2.3.3流的打开与关闭

使用标准I/O打开文件的函数有fopen() 、fdopen() 、freopen()。他们可以以不同的模式打开文件，都返回一个指向FILE的指针，该指针指向对应的I/O流。此后，对文件的读写都是通过这个FILE指针来进行。

表7 fopen()函数描述
第一部分标准IO及文件IO（第2章文件I/O）

关闭流的函数为fclose()，该函数将流的缓冲区内的数据全部写入文件中，并释放相关资源。
表8 fclose()函数描述
第一部分标准IO及文件IO（第2章文件I/O）

2.3.4流的读写

1、按字符（字节）输入/输出
字符输入/输出函数一次仅读写一个字符。

表9字符输入函数原型
第一部分标准IO及文件IO（第2章文件I/O）

函数getchar等价于get(stdin)。前两个函数的区别在于getc可被实现为宏，而fgetc则不能实现为宏。这意味着：
1）getc 的参数不应当是具有副作用的表达式。
2）因为fgetc一定是一个函数，所以可以得到其地址。这就允许将fgetc的地址作为一个参数传给另一个参数；
3）调用fgetc所需时间很可能长于调用getc，因为调用函数通常所需的时间长于调用宏。
这三个函数在返回下一个字符时，会将其unsigned char 类型转换为int类型。说明为什么不带符号的理由是，如果是最高位为1也不会使返回值为负。要求整数返回值的理由是，这样就可以返回所有可能的字符值再加上一个已出错或已达到文件尾端的指示值。在

#include <stdio.h> 
int ferror (FILE *fp);  
int feof (FILE *fp);

两个函数返回值；若条件为真则返回非0值（真），否则返回0（假）；
在大多数实现中，为每个流在FILE对象中维持了两个标志：
1) 出错标志。
2) 文件结束标志。

表10字符输出-函数原型
第一部分标准IO及文件IO（第2章文件I/O）

putc()和fputc()向指定的流输出一个字符（节），putchar()向stdout输出一个字符（节）。
2、按行输入、输出
行输入/输出函数一次操作一行。
表11行输入函数原型
第一部分标准IO及文件IO（第2章文件I/O）

这两个函数都指定了缓冲区的地址，读入的行将送入其中。gets从标准输入读，而fgets则从指定的流读。
gets函数容易造成缓冲区溢出，不推荐使用；
fgets从指定的流中读取一个字符串，当遇到 \n 或读取了 size - 1个字符串后返回。注意，fgets不能保证每次都能读出一行。如若该行（包括最后一个换行符）的字符数超过size -1 ，则fgets只返回一个不完整的行，但是，缓冲区总是以null字符结尾。对fgets的下一次调用会继续执行。
表12行输出函数原型
第一部分标准IO及文件IO（第2章文件I/O）

函数fputs将一个以null符终止的字符串写到指定的流，尾端的终止符null不写出。注意，这并不一定是每次输出一行，因为它并不要求在null符之前一定是换行符。通常，在null符之前是一个换行符，但并不要求总是如此。
下面举个例子：模拟文件的复制过程：
【参见附件/cp.c】

#include <stdio.h> 
#include <string.h> 
#include <unistd.h> 
#include <fcntl.h> 
#define maxsize 5 

int main(int argc, char *argv[])  
{  
    FILE *fp1 ,*fp2;  
    char buffer[maxsize];  
    char *p,*q;  
    if(argc < 3)  
    {  
printf("Usage:%s <srcfile> <desfile>\n",argv[0]);  
            return -1;  
}  

    if((fp1 = fopen(argv[1],"r")) == NULL)  
    {  
perror("fopen argv[1] fails");  
return -1;  
    }  
    if((fp2 = fopen(argv[2],"w+")) == NULL)  
    {  
perror("fopen argv[2] fails");  
return -1;  
}  

    while((p = fgets(buffer,maxsize,fp1)) != NULL)  
    {  
fputs(buffer,fp2);  
    }  
    if(p == NULL)  
    {  
if(ferror(fp1))  
perror("fgets failed");  
if(feof(fp1))  
printf("cp over!\n");  
    }  
    fclose(fp1);  
    fclose(fp2);  
    return 0;  
}

执行结果如下：
第一部分标准IO及文件IO（第2章文件I/O）
我们可以看到，这里将time.c拷贝给1.c ，1.c和time.c大小一样，都是319个字节；
3、以指定大小为单位读写文件

2.3.3格式化输入输出

这里举个相关应用例子：循环记录系统时间
实验内容：程序每秒一次读取依次系统时间并写入文件。
【参见附件/time.c】

#include <stdio.h> 
#include <unistd.h> 
#include <time.h> 
#define N 64 

int main(int argc, char *argv[])  
{  
    int n;  
    char buf[N];  
    FILE *fp;  
    time_t t;  
    if(argc < 2)  
    {  
        printf("Usage : %s <file >\n",argv[0]);  
        return -1;  
    }  
    if((fp = fopen(argv[1],"a+")) == NULL)  
    {  
        perror("open fails");  
        return -1;  
    }  
    while(1)  
    {  
        time(&t);  
        fprintf(fp,"%s",ctime(&t));  
        fflush(fp);  
        sleep(1);  
    }  
    fclose(fp);  
    return 0;  
}

执行结果如下：
第一部分标准IO及文件IO（第2章文件I/O）

2.4从标准输入输出看流和缓冲区

学习标准输入输出，我们都会遇到一个概念，流和缓冲区，但到底什么是流，什么是缓冲区呢？
书《C Primer Plus》上说，C程序处理一个流而不是直接处理文件。后面的解释十分抽象：流（stream）是一个理想化的数据流，实际输入或输出映射到这个数据流』。这个流具体是一个怎么样的东西呢？
流这个定义非常的形象。我们可以这样理解：
你声明一个FILE *fp ，并把fopen(某个文件)返回的值赋予fp这两个动作就相当于建立了一个水龙头，当你用getc(fp)之类的输入函数读取文件字符时就相当于拧开了水龙头，每读取一个字符，这个文件就像水一样的流动一下，fp所指的地址自然就向后移动了一位。

int ch;  
while（(ch=getc(fp))!=EOF）  
    putchar(ch);

你看这个循环，可以读取一个文件的所有字符。如果不是流的话，ch永远是第一个字符，不会更新。也可以理解为，fp自动++（一个字符的大小）。
但流的概念意味着什么呢？
1) 流是独立于设备之外而操纵外设一种逻辑手段。
2) 大多数外设都是互异的，所以（操纵）它们需要专门的编程技术。
3) 流对程序员隐藏这些不同点，而准许他们以同样的方式来处理大多数外设。
4) 考虑到一连串的字符需要一次读一个，流（相当于）是具有缓冲作用的接口。
5) 个人计算机都是基于流架构的。
各大权威对流的说法有些不一致，我认为流既是数据的源或目的地的抽象，也是源和目的地之间流动信息的表示。但流起码都暗含以下的几个方面：
1、流是一个抽象的概念，是对信息的一种表达；在程序中，流就是对某个对象输入输出信息的抽象。就像运输工具是对一切运动载体的抽象一样。
2、流是一种“动”的概念，静止存储在介质上的信息只有当它按一定的序列准备“运动”时才称为流。“从程序移进或移出字节”就是“动”的表现。静止的信息具有流的潜力，但不一定是流，就像没有汽油不能行走的汽车一样，它具有运输工具的潜力，但它还不是运输工具（因为它很有可能被当作房子来用了，我就在大街上看见有精明的商人用火车车厢来做酒吧）。
3、流有源头也有目的地；程序中各种移动的信息都有其源和目的，记得编程（特别是汇编）时，老是要确定好某个操作的源操作数和目的操作数。借用佛教一言也即是：“万物皆有因果”，这也就像长江一样，西自唐古拉，而东去太平洋。在高速公路上飞跑的汽车，它必有其出发地和目的地。
4、流一定带有某种信息，没有任何内容的流带着自身来表达“空”信息。就像运输工具一样，它不运货的时候就运着自己这一身的零件（包括驾驶员）并把一样东西运到目的地，那就是它自己和一个“跑空车”的信息。流有最小的信息单元就是二进制位，含有最小的信息包就是字节，C标准库提供两种类型的流：二进制流（binary stream）和文本流（text stream）。二进制流是有未经处理的字节构成的序列；文本流是由文本行组成的序列。而在著名的UNIX系统中，文本流和二进制流是相同的（identical）。
5、流有源头也有目的地，那么它必定与源头和目的地相关联。但人们操作流的时候，最关心的还是其目的地，也就是一个定向（orientation）的意思，就像司机运货一样，它首要关心的问题是目的地，而非起点（操作者都知道）。在C语言中，通过打开流来关联流及其目的地，使用的函数是fopen()，该函数返回一个指向文件的指针（FILE *），该指针包含了足够的可以控制流准确地到达目的地的信息。
FILE是一个结构体（摘自TC2.0中stdio.h文件）
/* Definition of the control structure for streams
*/
typedef struct {
short level; /* fill/empty level of buffer */
unsigned flags; /* File status flags */
char fd; /* File descriptor */
unsigned char hold; /* Ungetc char if no buffer */
short bsize; /* Buffer size */
unsigned char buffer; / Data transfer buffer */
unsigned char curp; / Current active pointer */
unsigned istemp; /* Temporary file indicator */
short token; /* Used for validity checking */
} FILE; /* This is the FILE object */
将它称为流控制结构体（control structure for streams）真好表现出其功能来。举个例子就好像一卡车司机要把货物运到X公司，公司主管就会给他一张地图及X公司的基本信息，这些材料所提供的信息如果足够的话，那么它就能指导着司机准确地将货物送达了。C中FILE这个结构体所起的作用就好像是运输公司把一切有用的指导信息封装起来的档案袋一样。而已有关联的流要终止这种关联，就必须关闭流，使用的函数是fclose()，就像运货公司若不再给X公司运货了，那么他们就必须要终止合作协议了。
这里要注意的是：C语言中stdin、stdout、stderr分别是标准输入流、标准输出流及标准出错流的逻辑目的，他们都默认对应相应的物理终端。在程序运行伊始，不需要进行open()操作，流自动打开。
那缓冲区又是什么意思呢？
缓冲区（Buffer）：
为了匹配计算机快速设备和慢速设备间的通信步伐，计算机中大量使用硬件缓冲区（如CPU中的Cache，内存相对于硬盘和CPU），流是传输信息的一种逻辑表示，对流的各种不同操作也可能存在使用缓冲的需求。但是这里的buffer只是一种逻辑概念，不是物理设备。缓冲区存在于流与具体的设备终端或者存储介质上的文件之间。就好像运货到一个公司里一样，合同上的要求是运到X公司，但是实际上是真的把货物运到X公司的总部大楼吗？不是。应该是运到X公司的仓库中。这里的仓库就有点像我们所说的缓冲区了。也可以这么说，流运动到目的，先经过的是缓存区。
以scanf() printf()为例：
• 缓冲区（流）负责在输入/输出设备和程序之间建立联系。
1) 输入设备->内存缓冲区(stdin)->程序
2) 程序->内存缓冲区(stdout)->输出设备
• 是一块临时的存储区域，或在内存中，或在设备的控制卡上
缓冲类型
标准库提供缓冲是为了减少对read和write的调用。提供的缓冲有三种类型(整理自APUE):
1) 全缓冲
在这种情况下,实际的I/O操作只有在缓冲区被填满了之后才会进行。对驻留在磁盘上的文件的操作一般是有标准I/O库提供全缓冲。缓冲区一般是在第一次对流进行I/O操作时,由标准I/O函数调用malloc函数分配得到的。
术语flush描述了标准I/O缓冲的写操作。缓冲区可以由标准I/O函数自动flush(例如缓冲区满的时候);或者我们对流调用fflush函数。
2) 行缓冲
在这种情况下,只有在输入/输出中遇到换行符的时候,才会执行实际的I/O操作。这允许我们一次写一个字符,但是只有在写完一行之后才做I/O操作。一般的,涉及到终端的流–例如标注输入(stdin)和标准输出(stdout)–是行缓冲的。
3) 无缓冲
标准I/O库不缓存字符。需要注意的是,标准库不缓存并不意味着操作系统或者设备驱动不缓存。
当然，我们常用的scanf() 与 printf() 属于行缓冲，下面我们来看个例子，可以帮助我们理解缓冲区在标准输入输出中的作用：

#include <stdio.h> 
int main()  
{  
    printf("hello world");  
    while(1);  
}

我们看看输出结果：
第一部分标准IO及文件IO（第2章文件I/O）
打出是个空的，为什么呢？
我们上面提到标准输入输出是行缓冲，即一行满了才会刷新，那什么是刷新呢？刷新就是将数据从缓冲区取出来，真正能刷新，要满足什么条件呢？
1、满刷新，即一行满了（1024个字节）才会刷新；
2、遇到’\n’会刷新；
3、调用fflush()函数；
4、程序结束 fclose();
我们可以看到上面的程序，应为有while(1),程序一直没有结束，没有’\n’，没有满行，没有fflush(),所以并不会输出；
这样理解的话，我们可以改动一下了，就写一个吧，加’\n’:

#include <stdio.h> 
int main()  
{  
    printf("helloworld\n");  
    while(1);  
}

执行结果如下：
第一部分标准IO及文件IO（第2章文件I/O）
可以看到打印出来了，其他方法在这就不写了，大家可有从这个简单的例子中看到缓冲区与流的概念。

小贴士：出错处理

1. errno变量
文件 < errno.h> 中定义了符号 errno 以及可以赋予它的各种常量,这些常量都是以字符 E 开头。例如,若 errno 等于常量 EACCES,表示产生了权限问题(例如,没有打开所要求文件的足够权限)。
当 UNIX 函数出错时,常常返回一个负值,而且将整型变量 errno 设置成含有附加信息的各个常量。例如,open 函数如果成功执行则返回一个非负文件描述符,如出错则返回 -1。在 open 出错时,有大约 15 种不同的errno 值(文件不存在、权限问题等)。
对于 errno 应该知道两条规则：
规则一：如果没有出错,则errno的值不会被一个例程清除。因此,仅当函数的返回值指明出错时,才校验 errno 的值。
规则二：任一函数都不会将errno的值设置为0,在

#include <string.h> 
#include <errno.h> 
char *strerror(int errnum);

返回值：指向消息字符串的指针
此函数将 errnum(它通常就是 errno 值)映射为一个出错信息字符串,并且返回此字符串的指针。
2)perror()
perror 函数基于 errno 的当前值,在标准出错上产生一条出错信息,然后返回。

#include <stdio.h> 
 void perror(const char *msg);

它首先输出由 msg 指向的字符串,然后是一个冒号,一个空格,接着是对应于 errno 值的出错信息,最后是一个换行符。
例子：
下面代码展示了这两个出错函数的使用方法:：

#include <string.h> 
#include <stdio.h> 
#include <errno.h> 
#include <stdlib.h> 
int  main(int argc, char *argv[])  
{  
    fprintf(stderr, "EACCES: %s\n", strerror(EACCES));  
    errno = ENOENT;  
    perror(argv[0]);  
    exit(0);  
}

执行结果如下：

fs@ubuntu:~/qiang/error$ ./error   
EACCES: Permission denied  
./error: No such file or directory  
fs@ubuntu:~/qiang/error$

2. 打印所有错误信息
C 标准库定义了sys_nerr 用于记录错误信息总个数,下面程序通过循环来打印所有信息。

#include <string.h> 
#include <stdio.h> 
#include <errno.h> 
#include <stdlib.h> 
int main(int argc, char *argv[])  
{  
int idx = 0;  
for (idx = 0; idx < sys_nerr; idx++)
{  
printf("Error #%3d: %s\n", idx, strerror(idx));  
      }  
exit(0);  
}

执行结果如下：
第一部分标准IO及文件IO（第2章文件I/O）
….

3. 多线程扩展
在支持线程的环境中,多个线程共享进程地址空间,每个线程都有属于它自己的局部 errno 以避免一个线程干扰另一个线程。
函数 strerror() 不是线程安全的。因为该函数将 errnum 对应的字符串保存在一个静态的缓冲区中,然后将该缓冲区的指针返回。另一个线程调用 strerror() 就会重新设置静态缓冲区的内容。
4. 出错恢复
可将 < errno.h> 中定义的各种出错分成致命性的和非致命性的两类。对于致命性的错误,无法执行恢复动作,最多只能在用户屏幕上打印出一条出错信息,或者将一条出错信息写入日志文件,然后终止。而对于非致命性的错误,有时可以较妥善地进行处理。

本章参考附件

点击进入

秒客网

第一部分标准IO及文件IO（第2章文件I/O）

2.1文件I/O与标准文件I/O

2.1.1文件I/O和标准I/O的概念

2.1.2文件I/O和标准I/O的区别

2.1.3各自使用的函数

2.1.4系统调用与库函数

2.2文件I/O

2.2.1文件打开与和关闭

2.2.2文件读写

2.2.3文件定位

2.3标准I/O

2.3.1标准I/O的由来

2.3.2流的含义

2.3.3流的打开与关闭

2.3.4流的读写

2.3.3格式化输入输出

2.4从标准输入输出看流和缓冲区

小贴士：出错处理

本章参考附件

相关文章

第一部分 标准IO及文件IO（第2章 文件I/O）

2.1文件I/O与标准文件I/O

2.1.1文件I/O和标准I/O的概念

2.1.2文件I/O和标准I/O的区别

2.1.3各自使用的函数

2.1.4系统调用与库函数

2.2文件I/O

2.2.1文件打开与和关闭

2.2.2文件读写

2.2.3文件定位

2.3标准I/O

2.3.1标准I/O的由来

2.3.2流的含义

2.3.3流的打开与关闭

2.3.4流的读写

2.3.3格式化输入输出

2.4从标准输入输出看流和缓冲区

小贴士：出错处理

本章参考附件

相关文章

第一部分标准IO及文件IO（第2章文件I/O）