linux C编程之常用文件I/O操作

今天我们总结一下，linux中常用文件I/O操作。

     首先让我们看一下，什么是文件I/O:

        所谓文件I/O就是：对于I/O就是input/output，输入/输出。文件IO的意思就是读写文件。

1、linux给我们留的常用文件I/O接口。

    1、open close write read lseek

2、文件操作的一般步骤：

    1、在linux中要操作一个文件，一般是先open打开一个文件，得到文件描述符，然后对文件进行读写操作（或其他操作），最后是close关闭文件即可。

    2、强调一点：我们对文件进行操作时，一定要先打开文件，打开成功之后才能操作，如果打开失败，就不用进行后边的操作了，最后读写完成后，一定要关闭文件，否则会造成文件损坏。

    3、文件平时是存放在块设备中的文件系统文件中的，我们把这种文件叫静态文件，当我们去open打开一个文件时，linux内核做的操作包括：内核在进程中建立一个打开文件的数据结构，记录下我们打开的这个文件；内核在内存中申请一段内存，并且将静态文件的内容从块设备中读取到内核中特定地址管理存放（叫动态文件）。

    4、打开文件以后，以后对这个文件的读写操作，都是针对内存中的这一份动态文件的，而并不是针对静态文件的。当然我们对动态文件进行读写以后，此时内存中动态文件和块设备文件中的静态文件就不同步了，当我们close关闭动态文件时，close内部内核将内存中的动态文件的内容去更新（同步）块设备中的静态文件。

    5、为什么这么设计，不直接对块设备直接操作。

      块设备本身读写非常不灵活，是按块读写的，而内存是按字节单位操作的，而且可以随机操作，很灵活。

3、重要概念：

    文件描述符：   

    1、对于内核而言，所有打开文件都由文件描述符引用。文件描述符是一个非负整数。当打开一个现存文件或者创建一个新文件时，内核向进程返回一个文件描述符。当读写一个文件时，用open和creat返回的文件描述符标识该文件，将其作为参数传递给read和write。

按照惯例，UNIX shell使用文件描述符0与进程的标准输入相结合，文件描述符1与标准输出相结合，文件描述符2与标准错误输出相结合。STDIN_FILENO、STDOUT_FILENO、STDERR_FILENO这几个宏代替了0、1、2这几个魔数。

    2、文件描述符，这个数字在一个进程中表示一个特定含义，当我们open一个文件时，操作系统在内存中构建了一些数据结构来表示这个动态文件，然后返回给应用程序一个数字作为文件描述符，这个数字就和我们内存中维护的这个动态文件的这些数据结构绑定上了，以后我们应用程序如果要操作这个动态文件，只需要用这个文件描述符区分。

    3、文件描述符的作用域就是当前进程，出了这个进程文件描述符就没有意义了。

open函数打开文件，打开成功返回一个文件描述符，打开失败，返回-1。

补充：这里我们补充一点，

        1、学习linux过程中注意学会使用man手册，查询帮助文档。 

        2、man 1 xx查linux shell命令，man 2 xxx查API， man 3 xxx查库函数

4、常用文件I/O操作的使用：

    1、open函数（打开文件操作） 

需要用到的头文件
    #include<sys/types.h>
    #include<sys/stat.h>
    #include<fcntl.h>
函数原型：
       int open(const char *pathname, int flags);
       int open(const char *pathname, int flags, mode_t mode);
                                           返回值：若成功返回文件描述符，若出错返回 -1

    对于open函数而言，仅当创建新文件时才使用第三个参数。namepath是要打开或创建的文件的名字。oflag参数可以用来说明函数的多个选项。用下列一个或者多个常数进行或运算构成oflag参数（这些参数定义在<fcntl.h>头文件中）：

open函数flags参数详解：

    读写权限：O_RDONLY O_WRONLY O_RDWR     

        O_RDONLY 只读打开

        O_WRONLY 只写打开

        O_RDWR  可读可写打开

    当我们附带了权限后，打开的文件就只能按照这种权限来操作。以上这三个常数中应当只指定一 个。下列常数是可选择的：     

        O_CREAT 若文件不存在则创建它。使用此选项时，需要同时说明第三个参数mode，用其说明该新文件的存取许可权限。

        O_EXCL 如果同时指定了OCREAT，而文件已经存在，则出错。这可测试一个文件是

否存在，如果不存在则创建此文件成为一个原子操作。3 . 11节将较详细地说明原子操作。

        O_APPEND 每次写时都加到文件的尾端。

        O_TRUNC 属性去打开文件时，如果这个文件中本来是有内容的，而且为只读或只写成功打开，则将其长度截短为0。

重点：

   一： 打开存在并有内容的文件时：O_APPEND、O_TRUNC

    (1)思考一个问题：当我们打开一个已经存在并且内部有内容的文件时会怎么样？

    可能结果1：新内容会替代原来的内容（原来的内容就不见了，丢了）

    可能结果2：新内容添加在前面，原来的内容继续在后面

    可能结果3：新内容附加在后面，原来的内容还在前面

    可能结果4：不读不写的时候，原来的文件中的内容保持不变

   （2)O_TRUNC属性去打开文件时，如果这个文件中本来是有内容的，则原来的内容会被丢弃。这就对应上面的结果1

    (3)O_APPEND属性去打开文件时，如果这个文件中本来是有内容的，则新写入的内容会接续到原来内容的后面，对应结果3

    (4)默认不使用O_APPEND和O_TRUNC属性时就是结果4

    (5)如果O_APPEND和O_TRUNC同时出现会会清空文件。

    二：打开不存在的文件时：O_CREAT、O_EXCL

    (1)思考：当我们去打开一个并不存在的文件时会怎样？当我们open打开一个文件时如果这个文件名不存在则会打开文件错误。

    (2)vi或者windows下的notepad++，都可以直接打开一个尚未存在的文件。

    (3)open的flag O_CREAT就是为了应对这种打开一个并不存在的文件的。O_CREAT就表示我们当前打开的文件并不存在，我们是要去创建并且打开它。

    (4)思考：当我们open使用了O_CREAT，但是文件已经存在的情况下会怎样？经过实验验证发现结果是报错。

    (5)结论：open中加入O_CREAT后，不管原来这个文件存在与否都能打开成功，如果原来这个文件不存在则创建一个空的新文件，如果原来这个文件存在则会重新创建这个文件，原来的内容会被消除掉（有点类似于先删除原来的文件再创建一个新的）

    (6)这样可能带来一个问题？我们本来是想去创建一个新文件的，但是把文件名搞错了弄成了一个老文件名，结果老文件就被意外修改了。我们希望的效果是：如果我CREAT要创建的是一个已经存在的名字的文件，则给我报错，不要去创建。

    (7)这个效果就要靠O_EXCL标志和O_CREAT标志来结合使用。当这连个标志一起的时候，则没有文件时创建文件，有这个文件时会报错提醒我们。

    (8)open函数在使用O_CREAT标志去创建文件时，可以使用第三个参数mode来指定要创建的文件的权限。mode使用4个数字来指定权限的，其中后面三个很重要，对应我们要创建的这个文件的权限标志。譬如一般创建一个可读可写不可执行的文件就用0666

        O_NOCTTY 如果pathname指的是终端设备，则不将此设备分配作为此进程的控制终端。9.6节将说明控制终端。

        O_NONBLOCK 如果pathname指的是一个FIFO、一个块特殊文件或一个字符特殊文件，则此选择项为此文件的本次打开操作和后续的I/O操作设置非阻塞方式。（只用于设备文件，而不用于普通文件。）

    (1)阻塞与非阻塞。如果一个函数是阻塞式的，则我们调用这个函数时当前进程有可能被卡住（阻塞住，实质是这个函数内部要完成的事情条件不具备，当前没法做，要等待条件成熟），函数被阻塞住了就不能立刻返回；如果一个函数是非阻塞式的那么我们调用这个函数后一定会立即返回，但是函数有没有完成任务不一定。

    (2)阻塞和非阻塞是两种不同的设计思路，并没有好坏。总的来说，阻塞式的结果有保障但是时间没保障；非阻塞式的时间有保障但是结果没保障。

    (3)操作系统提供的API和由API封装而成的库函数，有很多本身就是被设计为阻塞式或者非阻塞式的，所以我们应用程度调用这些函数的时候心里得非常清楚。

    (4)我们打开一个文件默认就是阻塞式的，如果你希望以非阻塞的方式打开文件，则flag中要加O_NONBLOCK标志。

    O_SYNC 使每次write都等到物理I/O操作完成

    (1)write阻塞等待底层完成写入才返回到应用层。

    (2)无O_SYNC时write只是将内容写入底层缓冲区即可返回，然后底层（操作系统中负责实现open、write这些操作的那些代码，也包含OS中读写硬盘等底层硬件的代码）在合适的时候会将buf中的内容一次性的同步到硬盘中。这种设计是为了提升硬件操作的性能和销量，提升硬件寿命；但是有时候我们希望硬件不好等待，直接将我们的内容写入硬盘中，这时候就可以用O_SYNC标志。

    2、creat函数（也可用creat函数创建一个新文件）

需要用到的头文件
#include<sys/types.h>
#include<sys/stat.h>
#include<fcutl.h>
 函数原型：
 int creat(const char *pathname, mode_t mode);
                                         返回：若成功为只写打开的文件描述符，若出错为-1

    此函数等效于 open(pathname,O_WRONLY|O_CRAT|O_TRUNC,mode);

    3、read 函数（用read函数从打开的文件中读取数据）

需要的头文件：
#include<unistd.h>
函数原型：
ssize_t read(int filedes,void *buffer,size_t nbytes);
返回值：读取到字节数，若已到文件尾0，则返回-1如果read成功，则返回读取到字节数。如已到文件结尾返回0；

有多种情况可使实际读到的字节数少于要求读字节数：

1、读取普通文件时，在读到要求字节数之前已经到达了文件结尾。例如，若在到达文件尾端之前还有30个字节，而要求读100个字节，则read返回30，下一次调用read时，它将返回0（文件尾端）。

2、当从终端设备读时，通常一次最多读一行

3、当从网络读时，网络中缓存机构可能造成返回值小于所要求读的字节数。

4、某些面向记录的设备，例如磁带，一次最多返回一个记录。

    4、write函数（用write函数向打开的文件写数据）

需要用到的头文件
#include<unistd.h>
函数原型：
ssize_t write(int filedes,const void buffer,size_t nbytes);
                                            返回值：若成功返回已写字节数，若出错返回-1
其返回值通常与参数nbyte的值不同，否则表示出错。write出错的一个常见原因是：磁盘已写满，或者超过了对一个给定进程的文件长度限制。

写入用write系统调用，write的原型和理解方法和read相似

    5、close函数（可以用close函数关闭一个打开是文件）

需要用到的头文件：
#include<unistd.h>
函数原型：
int close(int filedes);
                                                        返回值：成功返回0，若出错返回-1

当一个进程终止时，它所有的打开的文件都是由内核自动关闭。

    6、lseek函数

每个打开文件都有一个与其相关联的“当前文件位移量”。它是一个非负整数，用以度量从文件开始处计算的字节数。

需要用到的头文件
#include<sys/types.h>
#include<unistd.h>
函数原型：
off_t lseek(int filedes,off_t offset,int whence);
                                            返回值：若成功为新的文件的位移，若出错位-1

    对参数offset 的解释与参数whence的值有关。

    若whence是SEEK_SET，则将该文件的位移量设置为距文件开始处offset 个字节。

    若whence是SEEK_CUR，则将该文件的位移量设置为其当前值加offset, offset可为正或负。

    若whence是SEEK_END，则将该文件的位移量设置为文件长度加offset, offset可为正或负。*******************************************************************************************

重要概念：

    (1)文件指针：当我们要对一个文件进行读写时，一定需要先打开这个文件，所以我们读写的所有文件都是动态文件。动态文件在内存中的形态就是文件流的形式。

    (2)文件流很长，里面有很多个字节。那我们当前正在操作的是哪个位置？GUI模式下的软件用光标来标识这个当前正在操作的位置，这是给人看的。

    (3)在动态文件中，我们会通过文件指针来表征这个正在操作的位置。所谓文件指针，就是我们文件管理表这个结构体里面的一个指针。所以文件指针其实是vnode中的一个元素。这个指针表示当前我们正在操作文件流的哪个位置。这个指针不能被直接访问，linux系统用lseek函数来访问这个文件指针。

    (4)当我们打开一个空文件时，默认情况下文件指针指向文件流的开始。所以这时候去write时写入就是从文件开头开始的。write和read函数本身自带移动文件指针的功能，所以当我write了n个字节后，文件指针会自动向后移动n位。如果需要人为的随意更改文件指针，那就只能通过lseek函数了

    (5)read和write函数都是从当前文件指针处开始操作的，所以当我们用lseek显式的将文件指针移动后，那么再去read/write时就是从移动过后的位置开始的。

    (6)回顾前面一节中我们从空文件，先write写了12字节，然后read时是空的（但是此时我们打开文件后发现12字节确实写进来了）。

lseek函数几个用途：

    1、用lseek计算文件长度

(1)linux中并没有一个函数可以直接返回一个文件的长度。但是我们做项目时经常会需要知道一个文件的长度，怎么办？自己利用lseek来写一个函数得到文件长度即可。

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
typedef int file_t;

#define MAXLENG 1024

int main(int argc,char *argv[])
{
	file_t fd = -1;
	ssize_t ret = -1;
	if(2 != argc)
	{
		fprintf(stdout,"usage: %s filename \n",argv[0]);
		_exit(-1);
	}	

	char buffer[MAXLENG] = {0};

	fd = open(argv[1],O_RDONLY);
	
	//文件打开成功，文件指针指向文件开头
	if(-1 == fd)
 	{
		perror("open file error:");
		_exit(-1);
	}
	else
	{
		fprintf(stdout,"文件打开成功\n");
		ret = lseek(fd,0,SEEK_END);

	}
	
	
	
	fprintf(stdout,"文件长度是: %d\n",ret);

	return 0;
}

     2、用lseek构建空洞文件

(1)空洞文件就是这个文件中有一段是空的。

(2)普通文件中间是不能有空的，因为我们write时文件指针是依次从前到后去移动的，不可能绕过前面直接到后面。

(3)我们打开一个文件后，用lseek往后跳过一段，再write写入一段，就会构成一个空洞文件。

(4)空洞文件方法对多线程共同操作文件是及其有用的。有时候我们创建一个很大的文件，如果从头开始依次构建时间很长。有一种思路就是将文件分为多段，然后多线程来操作每个线程负责其中一段的写入。

补充：

  1、exit、_exit、_Exit退出进程

        (1)当我们程序在前面步骤操作失败导致后面的操作都没有可能进行下去时，应该在前面的错误监测中结束整个程序，不应该继续让程序运行下去了。

        (2)我们如何退出程序？

        第一种；在main用return，一般原则是程序正常终止return 0，如果程序异常终止则return -1。

        第一种：正式终止进程（程序）应该使用exit或者_exit或者_Exit之一。

  2、文件读写的一些细节

    <1> 、errno和perror

(1)errno就是error number，意思就是错误号码。linux系统中对各种常见错误做了个编号，当函数执行错误时，函数会返回一个特定的errno编号来告诉我们这个函数到底哪里错了。

(2)errno是由OS来维护的一个全局变量，任何OS内部函数都可以通过设置errno来告诉上层调用者究竟刚才发生了一个什么错误。

(3)errno本身实质是一个int类型的数字，每个数字编号对应一种错误。当我们只看errno时只能得到一个错误编号数字（譬如-37），不适应于人看。

(4)linux系统提供了一个函数perror（意思print error），perror函数内部会读取errno并且将这个不好认的数字直接给转成对应的错误信息字符串，然后print打印出来。

    <2>、read和write的count

(1)count和返回值的关系。count参数表示我们想要写或者读的字节数，返回值表示实际完成的要写或者读的字节数。实现的有可能等于想要读写的，也有可能小于（说明没完成任务）

(2)count再和阻塞非阻塞结合起来，就会更加复杂。如果一个函数是阻塞式的，则我们要读取30个，结果暂时只有20个时就会被阻塞住，等待剩余的10个可以读。

(3)有时候我们写正式程序时，我们要读取或者写入的是一个很庞大的文件（譬如文件有2MB），我们不可能把count设置为2*1024*1024，而应该去把count设置为一个合适的数字（譬如2048、4096），然后通过多次读取来实现全部读完。

    <3>、文件IO效率和标准IO

(1)文件IO就指的是我们当前在讲的open、close、write、read等API函数构成的一套用来读写文件的体系，这套体系可以很好的完成文件读写，但是效率并不是最高的。

(2)应用层C语言库函数提供了一些用来做文件读写的函数列表，叫标准IO。标准IO由一系列的C库函数构成（fopen、fclose、fwrite、fread），这些标准IO函数其实是由文件IO封装而来的（fopen内部其实调用的还是open，fwrite内部还是通过write来完成文件写入的）。标准IO加了封装之后主要是为了在应用层添加一个缓冲机制，这样我们通过fwrite写入的内容不是直接进入内核中的buf，而是先进入应用层标准IO库自己维护的buf中，然后标准IO库自己根据操作系统单次write的最佳count来选择好的时机来完成write到内核中的buf（内核中的buf再根据硬盘的特性来选择好的实际去最终写入硬盘中）。

   3、linux系统如何管理文件

       <1>、硬盘中的静态文件和inode（i节点）

        (1)文件平时都在存放在硬盘中的，硬盘中存储的文件以一种固定的形式存放的，我们叫静 态文件。

        (2)一块硬盘中可以分为两大区域：一个是硬盘内容管理表项，另一个是真正存储内容的区域。操作系统访问硬盘时是先去读取硬盘内容管理表，从中找到我们要访问的那个文件的扇区级别的信息，然后再用这个信息去查询真正存储内容的区域，最后得到我们要的文件。

        (3)操作系统最初拿到的信息是文件名，最终得到的是文件内容。第一步就是去查询硬盘内容管理表，这个管理表中以文件为单位记录了各个文件的各种信息，每一个文件有一个信息列表（我们叫inode，i节点，其实质是一个结构体，这个结构体有很多元素，每个元素记录了这个文件的一些信息，其中就包括文件名、文件在硬盘上对应的扇区号、块号那些东西·····）

强调：硬盘管理的时候是以文件为单位的，每个文件一个inode，每个inode有一个数字编号，对应一个结构体，结构体中记录了各种信息。

        (4)联系平时实践，大家格式化硬盘（U盘）时发现有：快速格式化和底层格式化。快速格式化非常快，格式化一个32GB的U盘只要1秒钟，普通格式化格式化速度慢。这两个的差异？其实快速格式化就是只删除了U盘中的硬盘内容管理表（其实就是inode），真正存储的内容没有动。这种格式化的内容是有可能被找回的。

     <2>、内存中被打开的文件和vnode（v节点）

        (1)一个程序的运行就是一个进程，我们在程序中打开的文件就属于某个进程。每个进程都有一个数据结构用来记录这个进程的所有信息（叫进程信息表），表中有一个指针会指向一个文件管理表，文件管理表中记录了当前进程打开的所有文件及其相关信息。文件管理表中用来索引各个打开的文件的index就是文件描述符fd，我们最终找到的就是一个已经被打开的文件的管理结构体vnode

        (2)一个vnode中就记录了一个被打开的文件的各种信息，而且我们只要知道这个文件的fd，就可以很容易的找到这个文件的vnode进而对这个文件进行各种操作。

     <3>、文件与流的概念

        (1)流（stream）对应自然界的水流。文件操作中，文件类似是一个大包裹，里面装了一堆字符，但是文件被读出/写入时都只能一个字符一个字符的进行，而不能一股脑儿的读写，那么一个文件中N多的个字符被挨个一次读出/写入时，这些字符就构成了一个字符流。

        (2)流这个概念是动态的，不是静态的。

        (3)编程中提到流这个概念，一般都是IO相关的。所以经常叫IO流。文件操作时就构成了一个IO流。