Linux基础IO - 简易文件接口FILE
Posted weixin_45138295
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Linux基础IO - 简易文件接口FILE相关的知识，希望对你有一定的参考价值。
如何理解缓冲区？
在之前的文章中我们实现一个简易的进度条程序，在这个程序里的输出缓冲区在哪里？为什么要存在？与struct file[缓冲区]，两者是一个概念吗？
我们来看一个简单地问题：
int main()
// C库
fprintf(stdout, "hello fprintf\\n");
const char* msg = "hello write\\n"; // 不需要 +1 向显示器写入与向普通文件写入一直
write(1, msg, strlen(msg));
fork();
return 0;
很容易就能够得到输出的结果为：
然而，当我们将原本的输出文件重定向到log文本文件中，就会有这样的现象产生：
很明显fprintf重复打印，那么为什么会有这样的情况呢？
我们平时在使用fprintf()，底层使用的是FILE是一个FILE结构体，这个结构体中除了需要封装fd之外还要预留一部分空间作为缓冲区，当我们在使用fprintf时，并不是直接写入操作系统，而是存放在缓冲区中，然后函数直接返回。C库会结合一定的刷新策略将缓冲区中的数据写入OS（write...）
一般在语言级别上刷新策略有以下几点：1、无缓冲 2、行缓冲（当我们将数据写入缓冲区时如果碰到了'\\n'就将缓冲区进行刷新） 3、全缓冲（当缓冲区写满的时候才进行刷新）；一般显示器采用的刷新策略使用的是行缓冲，而普通文件才用的刷新策略是全缓冲。缓冲区的存在是为了节省调用者的时间。当我们打开文件的时候就会得到FILE结构体， 缓冲区就在这个结构体中。
总结和上面的问题，从write接口无论有没有重定向或者fork()直接调用系统接口没有缓冲区，而调用fprintf时有了对应的缓冲区，向显示器打印时在fork之前就已经完成的打印，但是如果是向文件打印刷新策略就会变为全缓冲zaifork()之前缓冲区没有写满，等到fork()之后对应了两个进程都会发生刷新，并产生写时拷贝。
简易FILE
下面我们就可以自己通过系统接口，模仿C库做一个简单地封装FILE：
_MY_FILE
首先，头文件中定义了一个叫做MY_FILE的结构体，里面有与系统文件相关的fd，标志着刷新策略的flags标志位，一个缓冲区，和用来记录当前文件输入位置的变量：
#define NUM 1024
#define BUFF_NONE 0x1
#define BUFF_LINE 0x2
#define BUFF_ALL 0x4
typedef struct _MY_FILE
int fd;
int flags; // flush method
char outputbuffer[NUM];
int current; // 记录下次写入的位置
MY_FILE;
下面我们来简要的写一下基本的文件操作函数：
my_fopen()
使用这个函数首先需要我们对于文件的打开方式进行判断，这里简单地识别"a"/"w"/"r"，这三个方式，根据不同的方式对使用哪一种open函数进行判断。然后需要我们与C库一样创建一个MY_FILE的结构体来记录需要返回的相关信息，并对这个文件结构体进行初始化。
MY_FILE* my_fopen(const char* path, const char* mode)
// 识别标志位
int flag = 0;
if (strcmp(mode, "r") == 0) flag |= O_RDONLY;
else if (strcmp(mode, "w") == 0) flag |= (O_WRONLY | O_CREAT | O_TRUNC);
else if (strcmp(mode, "a") == 0) flag |= (O_WRONLY | O_CREAT | O_APPEND);
else
// other operator
// r+ w+ a+
// 尝试打开文件
mode_t m = 0666;
int fd = 0;
if (flag & O_CREAT) fd = open(path, flag, m);
else fd = open(path, flag);
if (fd < 0) return NULL;
// 给用户返回MY_FILE对象
MY_FILE* mf = (MY_FILE*)malloc(sizeof(MY_FILE));
if (mf == NULL)
close(fd);
return NULL;
// 初始化MY_FILE对象
mf->fd = fd;
// mf->flags = BUFF_LINE;
mf->flags |= BUFF_LINE;
memset(mf->outputbuffer, '\\0', sizeof(mf->outputbuffer));
// mf->outputbuffer[0] = 0
return mf;
my_fclose()
在使用close之前即关闭文件之前，需要我们将缓冲区进行刷新，将存放在缓冲区的数据拷贝给操作系统。
int my_fclose(MY_FILE* fp)
assert(fp);
// 冲刷缓冲区
if (fp->current > 0) my_fflush(fp);
// 关闭文件
close(fp->fd);
// 释放堆空间
free(fp);
// 指针置空
fp = NULL;
return 0;
my_fwrite()
这个函数首先要注意的是，需要判断C中的缓冲区是否已满，满了就需要向操作系统进行写入，否则先向缓冲区进行写入，这里还需要进行判断即用户输入的数据是否超过了缓冲区的大小，若是超过了就只能向C库中的缓冲区大小的数据。在更新完缓冲区后，就需要对缓冲区的刷新方式进行判断，若是全缓冲就要判断缓冲区是否已满，若满则写入；若是行缓冲就要判断在缓冲区中末尾是否有'\\0'，若有则写入，这里编写的函数返回的是写入的字节数。
// 这里认为返回的就是一次实际写入的字节数，不是返回的个数
size_t my_fwrite(const void* ptr, size_t size, size_t nmemb, MY_FILE* stream)
// 实际上是写入到了缓冲区中
// 缓冲区如果已经满了则写入
if (stream->current == NUM) my_fflush(stream);
// 根据缓冲区剩余情况，进行数据拷贝
size_t user_size = size * nmemb;
size_t my_size = NUM - stream->current; // 100 - 10 = 90
size_t writen = 0;
if (my_size > user_size)
memcpy(stream->outputbuffer + stream->current, ptr, user_size);
// 更新数据字段
stream->current += user_size;
writen = user_size;
else
memcpy(stream->outputbuffer + stream->current, ptr, my_size);
// 更新数据字段
stream->current += my_size;
writen = my_size;
// 开始计划刷新
// 不发生刷新的本质，不进行写入，就是不进行IO，不进行系统调用，所以my_fwrite函数调用会非常快，数据会暂时保存在缓冲区中
// 可以在缓冲区中积压多份数据，统一进行刷新写入，本质就是一次IO可以IO更多的数据，提高IO的效率
if (stream->flags & BUFF_ALL)
if (stream->current == NUM) my_fflush(stream);
else if (stream->flags & BUFF_LINE)
if (stream->outputbuffer[stream->current - 1] == '\\n') my_fflush(stream);
else
// TODO
return writen;
my_fflush
刷新时，使用系统接口write()来将输入写入OS中。
int my_fflush(MY_FILE* fp)
assert(fp);
// 将用户缓冲区中的数据，通过系统调用接口冲刷给OS
write(fp->fd, fp->outputbuffer, fp->current);
fp->current = 0;
fsync(fp->fd); // 强制刷新内核缓冲区
return 0;
验证MY_FILE
首先，编写一个验证函数
#include <unistd.h>
#include <string.h>
#define MYFILE "log.txt"
int main()
MY_FILE* fp = my_fopen(MYFILE, "w");
if (fp == NULL) return 1;
const char *str = "hello my fwrite";
int cnt = 5;
// 操作文件
while(cnt)
char buffer[1024];
// snprintf(buffer, sizeof(buffer), "%s:%d", str, cnt--);
snprintf(buffer, sizeof(buffer), "%s:%d\\n", str, cnt--);
size_t size = my_fwrite(buffer, strlen(buffer), 1, fp);
sleep(1);
printf("当前成功写入: %lu个字节\\n", size);
//my_fflush(fp);
// if(cnt % 5 == 0) my_fwrite("\\n", strlen("\\n"), 1, fp);
my_fclose(fp);
return 0;
运行的结果是这样的：当运行完5次的时候可以发现缓冲区依次就会被存储对应的字符串。这里我们使用的方式是行缓冲；会重复打印的原因就是我们每次循环的时候没有将current这个值进行修改，因此写入的my_fwrite函数对自己的缓冲区写入的时候就会不断地往后。
若是我们将 snprintf中的'\\n'去掉时，这样就会变为全缓冲，当缓冲区内数据写满的时候或者关闭文件时会进行打印。每次写入没有'\\n'，就是将缓冲区中数据不会进行IO，数据只是暂时拷贝到了对应的流中的缓冲区中。
下面我们让它每五次就刷新一次：可以看到下面的结果，这是因为我们使用的是全缓冲，然后每隔5秒就向文件里写入一个'\\n'，于是每隔5秒就会刷新一次
创作赢红包| Linux 基础IO——自己实现文件接口FILE
文章目录
模仿C库，自己封装一个最简单的文件接口 FILE
1. 创建makefile
创建makefile
testfile: main.c mystdio.c
gcc -o $@ $^
.PHONY:clean
clean:
rm -f testfile
2. mystdio.h ——接口的声明
创建MY_FILE结构体 内部包含文件描述符fd，输出缓冲区ou’tputbuffer 、flags刷新方法
分别通过C库中fopen 、fwrite、fclose 接口的实现，设计属于自己的接口
3. mystdio.c —— 接口的实现
1. MY_fopen的实现
1.识别标志位
分别实现了读、写追加方式
2. 尝试打开文件
若想打开文件，需要调用open函数
若需要创建文件，则需调用第二个open函数
由于open中的mode参数受umask影响，所以设置一个默认的mode
若不需要创建文件，则调用第一个open函数
3. 给用户返回MY_FILE对象，需要先创建对象
判断对象是否创建成功，若失败需要将文件关闭
4.初始化MY_FILE对象
将自己设置的结构体MY_FILE内部的fd赋值为 open函数打开的返回值fd
刷新方法设置成行缓冲
outputbuffer缓冲区中全部初始化为0
current代表缓冲区中没有数据
5.返回打开的文件
当关闭文件的时候，fclose（FILE*) 将C语言当中的文件指针传进来
当关闭文件的时候，C要自己帮助我们进行冲刷缓冲区
为了方便表述，在MY_FILE结构体添加current变量
current代表下次写入时应该写入什么位置
如 outputbuffer中有5个字符 ，对应下标0 1 2 3 4 ，所以cuurrent代表下标5
2.MY_close 的实现
冲刷缓冲区
自己实现一个fflush(刷新缓冲区)，叫做MY_fflush
判断缓冲区是否有数据，若有数据就刷新出去
3. MY_fwrite的实现
缓冲区为ptr，单个单元的大小为size，nmemb代表想要写入几个单元，写入对应的流中
实际上是往缓冲区里写的
1.缓冲区如果已经满了，就直接写入流中
刷新流的缓冲区
2.根据缓冲区剩余情况，进行拷贝
共分为两种情况，若剩余空间足够，则调用if语句，将用户从ptr拷贝的数据全部拷贝给缓冲区
同时由于缓冲区加入user_size个字节，要更新current的位置
若剩余空间不足够，则调用else语句，将从ptr拷贝的数据填满剩余空间即可
同时由于缓冲区加入MY_size个字节，要更新current的位置
通过调用sriten 代表实际写了多少字节，为了充当最后的的返回值
3. 开始计划刷新
主要分为全刷新和行刷新两种情况，其他不考虑
全刷新判断缓冲区是否满了，若满了则直接刷新缓冲区
行刷新判断是否遇见\\n，若遇见\\n则直接刷新缓冲区
对之前内容清空
为了防止出现每次打印都会有之前的内容情况，所以刷新之后要清空
在这种情况下，之前的内容会被打印出来
将current置为0后，下次写入就可以覆盖上次缓冲区内容
4. 整体代码
1. main.c
#include"mystdio.h"
#include<string.h>
#include<unistd.h>
#define MYFILE "log.txt"
int main()
MY_FILE*fp=MY_fopen(MYFILE,"w");
if(fp==NULL) return 1;
const char*str="hello world";
int cnt=5;
//操作文件
while(1)
char buffer[1024];
snprintf(buffer,sizeof(buffer),"%s:%d\\n",str,cnt--);
size_t size=MY_fwrite(buffer,strlen(buffer),1,fp);
sleep(1);
printf("当前成功写入:%lu个字节\\n",size);
MY_fclose(fp);
return 0;
2. mystdio.h
#include<stdio.h>
#define NUM 1024
#define BUFF_NONE 0x1 //表示无缓冲
#define BUFF_LINE 0x2 //行缓冲
#define BUFF_ALL 0x4 //全缓冲
typedef struct MY_FILE
int fd;//文件描述符
int flags;//刷新方法
char outputbuffer[1024];//输出缓冲区
int current;
MY_FILE;
MY_FILE *MY_fopen(const char *path, const char *mode);//自己写fopen
size_t MY_fwrite(const void *ptr, size_t size, size_t nmemb, MY_FILE *stream);//自己写的fwrite
int MY_fclose(MY_FILE *fp);//自己写的fwrite
int MY_fflush (MY_FILE*fp);//自己实现的缓冲区
3. mystdio.c
#include"mystdio.h"
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdlib.h>
#include<unistd.h>
#include<assert.h>
MY_FILE*MY_fopen(const char *path, const char *mode)//自己写fopen
int flag=0;
if(strcmp(mode,"r")==0)//说明当前使用读方式打开文件
flag |= O_RDONLY;//读取
else if(strcmp(mode,"w")==0)
flag |=(O_CREAT | O_WRONLY | O_TRUNC);//创建文件 以写的方式打开文件 清空文件
else if(strcmp(mode,"a")==0)
flag |=(O_CREAT | O_WRONLY | O_APPEND); //创建文件 以写的方式打开文件 追加
else
//其他不考虑
//2. 尝试打开文件
mode_t m=0666;
int fd=0;
//flag代表模式 r w a
if(flag & O_CREAT)
fd=open(path,flag,m);
else
//说明不需要打开
fd=open(path,flag);
if(fd<0)//当前打开文件失败
return NULL;
//3.给用户返回MY_FILE对象，需要先进行构建
MY_FILE*mf=(MY_FILE*)malloc(sizeof(MY_FILE));
if(mf==NULL)//申请空间失败
close(fd);//关闭文件
return NULL;
// 4. 初始化 MY_FILE对象
mf->fd=fd;//将上述的fd传入结构体的fd中
mf->flags=0;
mf->flags=BUFF_LINE;//设置成行缓冲
memset(mf->outputbuffer,'\\0',sizeof(mf->outputbuffer));//将outputbufeer中的内容全部初始化为0
mf->current=0;//代表缓冲区中没有数据
W>
size_t MY_fwrite(const void *ptr, size_t size, size_t nmemb,MY_FILE *stream)
// 1. 缓冲区如果已经满了，就直接写入
if(stream->current == NUM) MY_fflush(stream);
// 2. 根据缓冲区剩余情况，进行数据拷贝即可
size_t user_size = size * nmemb;
size_t my_size = NUM - stream->current; // 100 - 10 = 90
size_t writen = 0;
if(my_size >= user_size)
memcpy(stream->outputbuffer+stream->current, ptr, user_size);
//3. 更新计数器字段
stream->current += user_size;
writen = user_size;
else
memcpy(stream->outputbuffer+stream->current, ptr, my_size);
//3. 更新计数器字段
stream->current += my_size;
writen = my_size;
// 4. 开始计划刷新, 他们高效体现在哪里 -- TODO
// 不发生刷新的本质，不进行写入，就是不进行IO,不进行调用系统调用，所以MY_fwrite函数调用会非常快,数据会暂时保存在缓冲区中
// 可以在缓冲区中积压多份数据，统一进行刷新写入，本质：就是一次IO可以IO更多的数据，提高IO效率
if(stream->flags & BUFF_ALL)
if(stream->current == NUM) MY_fflush(stream);
else if(stream->flags & BUFF_LINE)
if(stream->outputbuffer[stream->current-1] == '\\n') MY_fflush(stream);
else
//TODO
return writen;
int MY_fflush(MY_FILE *fp)
assert(fp);
W> int n= write(fp->fd,fp->outputbuffer,fp->current);//将缓冲区中的current个数传入fd中
fp->current=0;
return 0;
int MY_fclose(MY_FILE *fp)//自己写的fwrite
assert(fp);//首先要保证fp不为空
//1. 冲刷缓冲区
if(fp->current>0)//说明缓冲区有数据
MY_fflush(fp);
//2. 关闭文件
close(fp->fd);
//3.释放堆空间
free(fp);
//4.指针置为NULL
fp=NULL;
return 0;
以上是关于Linux基础IO - 简易文件接口FILE的主要内容，如果未能解决你的问题，请参考以下文章