Linux文件操作

在C语言中，我们已经学习了文件相关的知识，那么在Linux中我们为什么还要再来学习文件呢？这是因为C语言中和Linux中，"文件"是2个不同的概念。所以我们要来学习Linux中对文件的操作。
在学习之前，我们先来回顾一下C语言中文件的一些知识。

C语言中的文件IO

我们复习一些重要的接口

fopen

fopen用来打开文件，在打开⽂件的同时，都会返回⼀个FILE*的指针变量指向该⽂件，也相当于建⽴了指针和⽂件的关系。头文件是<stdio.h>。fclose用来关闭文件。
它们的原型如下：

//打开⽂件
FILE * fopen ( const char * pathname, const char * mode );//关闭⽂件
int fclose ( FILE * stream );

• pathname：打开文件的路径
• mode：表⽰⽂件的打开模式，最常用的模式是r,w,a

r：只读。打开一个已经存在的文件，如果文件不存在，就会报错
w：只写。打开一个文件，如果文件不存在，则会建立一个新的文件。在写入之前，会对文件进行清空处理。
a：只写。向文本文件尾添加数据，如果文件不存在，则会建立一个新的文件。

我们发现w和a都是写入，而w是对文件重新写入，而a是在文本末尾进行写入。接下来，我们将学习一下这2个方式。
我们先来验证一下w方式。
我们创建一个myfile.c文件，写入以下代码：

#include<stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>int main()
{printf("PID = %d\n",getpid());FILE* f = fopen("log.txt","w");if(f == NULL){perror("file\n");return 1;}const char* message = "abcde";   fwrite(message,strlen(message),1,f);                      fprintf(stdout,"%s\n",message);fclose(f);return 0;
}

运行程序，得到结果：

其中fwrite接口的意思是向f中写入message中的内容。它的原型是：
size_t fwrite(const void* ptr, size_t size, size_t nmemb, FILE *stream);

• ptr：是一个指向要写入文件的数据的指针。该指针指向的内存区域中的数据将被写入文件。
• size：表示要写入的每个数据项的大小（以字节为单位）
• nmemb：表示要写入的数据项的数量。
• stream：这是一个指向FILE结构体的指针，代表要写入数据的文件流。通过fopen函数打开文件后，会返回一个指向FILE结构体的指针，这个指针就可以作为stream参数传递给fwrite函数。

下面我们向log.txt文件中写hello linux，再来运行这个程序，看看会发生什么。

可以看到，写入之前会把文件内容先清空，再进行写入。
接着我们来验证a方式。多运行几次之后，然后再看log.txt。

---

在C语言程序启动的时候，会默认打开3个流：

• stdin：标准输入流，绝大多数场景下是从键盘中获取。
• stdout：标准输出流，绝大多数场景下会将内容输出到显示器上。
• stderr：标准错误流绝大多数场景下会将内容输出到显示器上。
  这3个流我们会在后面继续了解。

Linux中的文件IO

在C语言中，所有文件都是通过FILE*指针来进行操作，而在Linux中，我们是通过fd来进行操作。
其中fd叫做“文件描述符”。

open接口(2号手册)

open接口使用的头文件是<sys/types.h>,<sys/stat.h>,<fcntl.h>，它用于打开一个文件。它的返回值是一个int类型，这个就是文件描述符fd，在C语言中我们通过FILE*来控制文件，而在Linux中，我们用fd来操作。它的接口原型如下：

int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);

• pathname：文件路径名称。
• flags：文件打开方式。
• mode：文件权限。

一般带有2个参数的open接口，我们通常要用在一个已经存在的文件；而3个参数的open接口用于不存在的文件，如果文件不存在，可以创建一个文件。
打开方式

方式	功能
O_RDONLY	以只读方式打开
O_WRONLY	以只写方式打开
O_RDWR	以读写方式打开
O_CREAT	如果文件不存在，则新建一个文件

下面，我们通过2个参数的ope接口来实验。先把log.txt文件删除，运行以下代码

#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
int main()
{int fd = open("log.txt", O_WRONLY);if(fd < 0){perror("open fail!");}return 0;
}

可以看到，文件创建失败。以此就可以看出在Linux文件中，通过以只写方式打开文件的话，文件不存在的话，不会创建一个文件。
而如果想新建一个文件，就需要用到第二个open接口函数。
int fd = open("log.txt",O_WRONLY | O_CREAT);
这个代码的意思是：通过只读方式打开文件，如果文件不存在则创建文件。

那么为什么要通过这样的方式来进行创建文件呢？这就需要了解open接口的实现方式，是通过位图方式来进行传参的，把所需的选项按照按位或即可。可以用一个简单的程序验证一下。

#define ONE (1<<0) // 1
#define TWO (1<<1) // 2
#define THREE (1<<2) // 4
#define FOUR (1<<3) // 8void show(int flags)
{if(flags&ONE) printf("hello function1\n");if(flags&TWO) printf("hello function2\n");if(flags&THREE) printf("hello function3\n");if(flags&FOUR) printf("hello function4\n");
}
int main()
{printf("-----------------------------\n");show(ONE);printf("-----------------------------\n");show(TWO);printf("-----------------------------\n");show(ONE|TWO);printf("-----------------------------\n");show(ONE|TWO|THREE);printf("-----------------------------\n");show(ONE|THREE);printf("-----------------------------\n");show(THREE|FOUR);printf("-----------------------------\n");return 0;
}

可以看到你想让哪个程序运行起来，就将它们按位或即可。

---

当我们运行完./myfile.exe之后，可以看到文件的权限是乱码，如果删掉该文件之后，文件权限还可能跟上次的不一样。所以我们需要第三个参数mode来控制文件的初始权限。
int fd = open("log.txt",O_WRONLY | O_CREAT,0666);这段代码可以把文件的权限初始化成0666。运行代码之后看看结果。

#include<stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>int main()
{// umask(0);int fd = open("log.txt",O_WRONLY|O_CREAT,0666);if(fd < 0){perror("open fail!");return -1;}                                                                      return 0;                                                            
}    

可以看到新建文件的权限是“0664”，这是因为文件的权限还要通过umask来决定，我的umask权限默认是0002。所以想让权限是0666还要在代码中加入umask(0)才可以(放在fd之前)。

close接口

用于关闭文件，头文件是<unistd.h>，原型是int close(int fd);
当使用的时候，直接传入对应文件的接口即可。

write接口(2号手册)

用于向文件中写入，需要的头文件是<unistd.h>，原型是：
ssize_t write(int fd, const void *buf, size_t count);

• fd：被写入的文件
• buf：被写入的字符串。
• count：写入字符的个数

我们执行以下代码

#include<stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>int main()
{umask(0);int fd = open("log.txt",O_WRONLY|O_CREAT,0666);const char* buf = "Hello Linux!\n";write(fd,buf,6);close(fd);return 0;                                                            
}    

可以看到，输出的结果就是6个字符Hello L。接着我们数组改成const char* buf = "xxx";，然后把write的第三个参数改成3，看看结果是什么。

为此我们可以知道一个事情，就是通过O_WRONLY进行写入时，不会把文件的内容进行清空，而是重头开始覆盖写。所以xxx会把原来的Hello L的前三个字符进行覆盖。
如果想要对文件的内容先情况，再进行写入的话，需要知道下面2个选项。

选项	功能
O_TRUNC	打开文件时情况文件内容
O_APPEND	以追加的方式进行写入

使用方法还是和上面的一样，这里就不再进行演示了。

• O_WRONLY|O_CREAT|O_TRUNC：以写的方式对文件进行写入，如果文件不存在则新建一个文件，打开文件时对文件内容进行清空。
• O_WRONLY|O_CREAT|O_APPEND：以写的方式对文件进行写入，如果文件不存在则新建一个文件，打开文件时在文件的末尾进行写入。

由上面的例子可以看出，C语言中的文件接口都是经过封装的，是库函数，方便用户使用。
例如：
C语言中的FILE* fp = fopen("log.txt","w"); 等价于 Linux中的int fd = open("log.txt",O_WRONLY|O_CREAT|O_TRUNC,0666);
而C语言中的"a"其实就是O_WRONLY|O_CREAT|O_APPEND
由此说明，fopen是用户操作接口，而open是系统操作接口。fopen就是对open进行了封装。

read接口(2号手册)

用于读取文件，头文件是<unistd.h>，原型是ssize_t read(int fd,void *buf,size_t count)
参数功能和write一样。返回值有3个。

• ·<0：表示读取失败。
• =0：表示读取到文件末尾
• >0：表示读取成功，返回读取到的字符个数。

先往log.txt文件中写入xxxxxxxxxxxxxxx(15个字符)，然后运行以下程序：

#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <string.h>int main()
{int fd = open("log.txt", O_RDONLY);char buf[1024];ssize_t ret1 = read(fd, buf, 1024);printf("ret1 = %d\n", ret1);printf("%s", buf);ssize_t ret2 = read(fd, buf, 1024);printf("ret2 = %d\n", ret2);close(fd);return 0;
}

这个程序开始时先用open打开文件，然后通过read将log.txt中的内容读取到buf数组中，随后将返回值给ret1，接着输出ret1和buf；再接着第二次读取文件内容，并把返回值给ret2。
在输出结果中，为什么第二次通过read读取时会是0呢？这是因为第一次读取的时候已经读到文件末尾了，所以第二次会返回0。
如果我们把第一次的read的参数改为5，那么结果又是什么呢？

第一次会读取5个字符，如果第二个read的参数大于字符个数的话，则会读取到文件结束，即第二次的返回值是剩下的字符个数，小于剩余的字符个数的话，会返回该读取的个数。

访问文件的本质

在Linux中，一切皆文件，而想要管理这些文件，就需要一个方式来整齐的进行管理，防止出现文件访问错误或者失败。所以在Linux中，有一个专门管理文件的结构体，叫做struct file。视图如下：

每个数组的元素都是一个指向struct file的指针，struct file对应一个打开的文件。而操作系统有一个全局的struct file_struct，用于统一管理所有进程打开的文件。
当我们打开文件时，操作系统在内存中要创建相应的数据结构来描述目标文件。于是就有了file结构体。表示一个已经打开的文件对象。而进程执行open系统调用，所以必须让进程和文件关联起来。每个进程都有一个指针*files, 指向一张表files_struct,该表最重要的部分就是包涵一个指针数组，每个元素都是一个指向打开文件的指针！所以，本质上，文件描述符就是该数组的下标。所以，只要拿着文件描述符，就可以找到对应的文件

文件描述符fd

通过对open函数的学习，我们知道了文件描述符就是一个小整数。在上面的图中已经写出文件描述符就是fd_array[]数组的下标。
我们可以多创建几个文件来看看，它们对应的下标，运行下面程序：

#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>int main()
{umask(0);int fd1 = open("log1.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);int fd2 = open("log2.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);int fd3 = open("log3.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);int fd4 = open("log4.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);if(fd1 < 0){perror("open fail!\n");}printf("fd1 = %d\n", fd1);printf("fd2 = %d\n", fd2);printf("fd3 = %d\n", fd3);printf("fd4 = %d\n", fd4);return 0;
}

可以看到，文件创建成功，但是fd为什么是从3开始依次排列的，数组下标不是从0开始的吗？
原因是Linux进程默认情况下会有3个缺省打开的文件描述符，分别是标准输入stdin:0， 标准输出stdout:1， 标准错误stderr:2。这3个是默认打开的。
0,1,2对应的物理设备一般是：键盘，显示器，显示器。我们来看看这三个的编号是否是0,1,2。
运行程序：

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>int main()
{printf("stdin->fd: %d\n", stdin->_fileno);printf("stdout->fd: %d\n", stdout->_fileno);printf("stderr->fd: %d\n", stderr->_fileno);return 0;
}

OK，这就很好的证明了stdin,stdout,stderr占用了0 1 2为编号的fd。

缓冲区

我们多多少少都听过缓冲区这个概念，但是我们还是不理解它的作用是什么，可以用来干什么。
简单来说：缓冲区是一块存储区域，用于暂时存放数据，以协调不同速度的设备之间的数据传输，或者在数据处理过程中起到暂存数据的作用，避免数据的丢失或处理不及时。
它的作用主要是用来进行数据暂存和提高效率的。
比如说你要给你的朋友寄个快递，你在西安，而你的朋友在新疆，如果你自己送的话需要花费财力和精力，在这期间不能干任何事；而如果你把快递交给快递公司的话，你就可以干其它的事情，只需要等几天你的朋友就能收到快递了，但是快递公司并不是收到一个快递就发一次，而是要等到把若干个快递收集起来，统一进行发送。这样就能提高效率了。
所以在上面我们了解到C语言的文件接口，是封装了底层的系统调用接口，如果用户频繁的调用fwrite，那么也会多次调用系统接口。于是C语言的设计者认为，反正数据都要被保存到内存当中，这个过程需要调用系统接口，所以就把fwrite写入的数据先保存到一个内存当中，等到合适的时候，再通过write接口，把这块内存当中的数据一次性的写入到磁盘当中。现在我们就知道这块区域叫做“缓冲区”。
不过我们平时所说的“缓冲区”叫做“用户级缓冲区”，是C语言提供给我们的。用户所使用的C语言文件接口，都会先写入到“缓冲区”当中，调用write接口时，会把之前所有的数据写入到操作系统当中，这个过程叫做“刷新缓冲区”。当然操作系统系统也有自己的“缓冲区”，叫做“内核缓冲区”，这个是由操作系统自己进行管理，用户无法干涉。我们这次只学习“用户级缓冲区”，而“内核缓冲区”等到后面的时候再进行学习。

用户级缓冲区刷新策略

刷新策略有3种：

• 无缓冲：直接刷新
• 行缓冲：只有当碰到\n才会进行刷新。(向显示器显示数据的时候采用这种方式)
• 全缓冲：当缓冲区满了的时候，才会进行刷新。(普通文件进行写入时采用这种方式)

当然，遇到程序结束时和用户使用fflush进行刷新时，必须马上刷新缓冲区里的数据。

证明缓冲区存在

说了这么多，我们如何证明缓冲区是存在的呢？下面我将通过程序来进行证明。

#include<stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>//文件缓冲区
int main()
{const char *fstr = "hello fwrite\n";const char *str = "hello write\n";                                                       printf("hello printf\n");fprintf(stdout,"hello fprintf\n");fwrite(fstr,strlen(fstr),1,stdout);write(1,str,strlen(str));fork();return 0;
}

这段代码分别使用系统接口write和用户接口printf/fprintf/fwrite接口来向显示器写入数据。输出的结果也符合预期。
现在我们在最后加上fork()语句，并且把输出结果重定向到log.txt文件当中。

这时我们会发现用户文件接口输出了2次，而系统接口只输出了一次。而且输出顺序与代码顺序不一样，这是为什么呢？
上面我们讲到过，向显示器中打印采用的是行刷新策略，而向普通文件中写入是全刷新策略。
所以在向显示器打印的时候，到最后进行fork()时，所有的数据都已经刷新完成了，此时fork()函数没有作用。
而将结果重定向到文件中时，\n不起作用，直到缓冲区满时才会刷新，而这些数据肯定不会将缓冲区占满，所以只有程序结束时才会刷新。父进程会执行fork()之前的操作，可能已经将部分数据写入了C语言标准输出的缓冲区中，但不一定立即显示在终端上。所以当fork()的时候，会创建一个子进程，子进程会继承父进程的代码和数据，子进程开始执行时，它也会有自己独立的缓冲区副本（对于 C 标准库的缓冲区而言）。当父子进程执行到return语句时，即要刷新缓冲区的时候，发生写时拷贝，这个时候就会调write接口，这时数据才会进入到系统级别的缓冲区，这样就产生了2份数据，分别向文件中进行输出。所以用户接口就输出了2次，而系统接口输出了一次。
输出结果的顺序是由于父子进程并发执行，并且输出操作涉及缓冲区和共享的文件描述符，所以最终在终端上的输出顺序是不确定的。
通过以上解释我们可以确定一个事，那就是缓冲区一定不是由操作系统提供的，而是由C语言标准库提供的。

---

下面，我们在fork()上面添加fflush(stdout)这段代码，并重定向输出到log.txt文件中，看看结果会有什么变化。

int main()
{const char *fstr = "hello fwrite\n";const char *str = "hello write\n";                                                       printf("hello printf\n");fprintf(stdout,"hello fprintf\n");fwrite(fstr,strlen(fstr),1,stdout);write(1,str,strlen(str));fflush(stdout);fork();return 0;
}

此时，结果只输出了一次。因为父进程执行fflush(stdout)后，此前通过printf、fprintf和fwrite输出到标准输出的内容会立即被输出到终端。接着执行fork()创建子进程。此时，父进程继续执行后续代码，但由于前面已经刷新了缓冲区，所以不会再有这些输出函数残留的未输出内容。write函数不使用 C 标准库的缓冲区，其输出仍然会相对直接地显示在终端上。
子进程是父进程的副本，它也会执行相同的代码逻辑。但是由于在父进程中已经刷新了标准输出的缓冲区，所以子进程开始执行时，标准输出缓冲区中没有来自父进程在执行fflush(stdout)之前的未输出内容。

---

我们来看一下源码中FILE结构体

struct _IO_FILE {int _flags; /* High-order word is _IO_MAGIC; rest is flags. */#define _IO_file_flags _flags//缓冲区相关/* The following pointers correspond to the C++ streambuf protocol. *//* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */char* _IO_read_ptr; /* Current read pointer */char* _IO_read_end; /* End of get area. */char* _IO_read_base; /* Start of putback+get area. */char* _IO_write_base; /* Start of put area. */char* _IO_write_ptr; /* Current put pointer. */char* _IO_write_end; /* End of put area. */char* _IO_buf_base; /* Start of reserve area. */char* _IO_buf_end; /* End of reserve area. *//* The following fields are used to support backing up and undo. */char *_IO_save_base; /* Pointer to start of non-current get area. */char *_IO_backup_base; /* Pointer to first valid character of backup area */char *_IO_save_end; /* Pointer to end of non-current get area. */struct _IO_marker *_markers;struct _IO_FILE *_chain;int _fileno; //封装的文件描述符#if 0int _blksize;#elseint _flags2;#endif_IO_off_t _old_offset; /* This used to be _offset but it's too small. */#define __HAVE_COLUMN /* temporary *//* 1+column number of pbase(); 0 is unknown. */unsigned short _cur_column;signed char _vtable_offset;char _shortbuf[1];/* char* _save_gptr; char* _save_egptr; */_IO_lock_t *_lock;#ifdef _IO_USE_OLD_IO_FILE
};

由此可得C语言缓冲区是在FILE结构体当中。另外内核缓冲区和用户缓冲区2个互不影响。

模拟实现用户层缓冲区

通过源码我们知道，缓冲区是在FILE结构体当中，所以我们需要创建一个结构体来存储这些数据。把代码创建到Mystdio.h文件当中。

// Mystdio.h
#ifndef __MYSTDIO_H__
#define __MYSTDIO_H__
#include <string.h>
#define SIZE 1024   //缓冲区的大小#define FLUSH_NOW 1    //无刷新
#define FLUSH_LINE 2   //行刷新
#define FLUSH_ALL 4    //全刷新typedef struct IO_FILE{int fileno;int flag; //char inbuffer[SIZE];//int in_pos;char outbuffer[SIZE];   //缓冲区int out_pos;    //当前缓冲区的位置
}_FILE;_FILE * _fopen(const char*filename, const char *flag);
int _fwrite(_FILE *fp, const char *s, int len);
void _fclose(_FILE *fp);
#endif

---

下面我们在Mystdio.c文件是中实现4个接口分别是fopen()/fwrite/fflush()/fclose()。
先来实现fopen()接口。

思路：我们实现三种打开方式，分别是w,r,a，这三种的实现方式都是类似的。我们知道C接口都是封装了系统调用接口，所以我们先调用open()接口，然后传入参数。完成之后，返回fd，如果fd大于0，说明文件打开成功，然后此时用malloc函数为FILE结构体开辟空间并进行初始化。

#define FILE_MODE 0666   //文件初始权限
// "w", "a", "r"
_FILE * _fopen(const char*filename, const char *flag)
{assert(filename);assert(flag);int f = 0;int fd = -1;if(strcmp(flag, "w") == 0) {f = (O_CREAT|O_WRONLY|O_TRUNC);fd = open(filename, f, FILE_MODE);}else if(strcmp(flag, "a") == 0) {f = (O_CREAT|O_WRONLY|O_APPEND);fd = open(filename, f, FILE_MODE);}else if(strcmp(flag, "r") == 0) {f = O_RDONLY;fd = open(filename, f);}else return NULL;if(fd == -1) return NULL;_FILE *fp = (_FILE*)malloc(sizeof(_FILE));if(fp == NULL) return NULL;fp->fileno = fd;    // 文件描述符//fp->flag = FLUSH_LINE;fp->flag = FLUSH_ALL;  //刷新方式fp->out_pos = 0;   // 缓冲区位置return fp;
}

---

fwrite()接口。

思路：将输入的字符串s复制到文件流的输出缓冲区outbuffer中，从当前的写入位置out_pos开始，写入长度为len的内容。然后更新写入位置out_pos += len。然后判断是用哪种刷新方式进行刷新。
直接刷新：此时会调用write(fp->fileno, fp->outbuffer, fp->out_pos)将缓冲区中的内容写入底层文件描述符（fileno），然后将写入位置重置为 0，即fp->out_pos = 0。
行刷新：检查缓冲区中最后一个写入的字符是否为换行符（fp->outbuffer[fp->out_pos - 1] == '\n'），如果是，则将缓冲区内容写入底层文件并重置写入位置。(这里不考虑中间会不会出现\n)
全刷新：只有当缓冲区满时才会刷新。检查写入位置是否等于缓冲区大小（fp->out_pos == SIZE），如果是，则将缓冲区内容写入底层文件并重置写入位置。
最后函数返回写入的长度len，表示成功写入的字节数。

int _fwrite(_FILE *fp, const char *s, int len)
{// "abcd\n"memcpy(&fp->outbuffer[fp->out_pos], s, len); // 没有做异常处理, 也不考虑局部问题fp->out_pos += len;if(fp->flag&FLUSH_NOW){write(fp->fileno, fp->outbuffer, fp->out_pos);fp->out_pos = 0;}else if(fp->flag&FLUSH_LINE){if(fp->outbuffer[fp->out_pos-1] == '\n'){ // 不考虑其他情况write(fp->fileno, fp->outbuffer, fp->out_pos);fp->out_pos = 0;}}else if(fp->flag & FLUSH_ALL){if(fp->out_pos == SIZE){write(fp->fileno, fp->outbuffer, fp->out_pos);fp->out_pos = 0;}}return len;
}

---

fflush()接口

void _fflush(_FILE *fp)
{if(fp->out_pos > 0){   //大于0说明缓冲区中有数据write(fp->fileno, fp->outbuffer, fp->out_pos);fp->out_pos = 0;}
}

---

fclose()接口

void _fclose(_FILE *fp)
{if(fp == NULL) return;_fflush(fp);    //刷新缓冲区close(fp->fileno);    //关闭文件描述符free(fp);
}

---

Mystdio.c需要的头文件

#include "Mystdio.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>

至此我们实现的模拟用户缓冲区的代码就完成了