【创作赢红包】| 【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>#defineMYFILE"log.txt"intmain(){    
  MY_FILE*fp=MY_fopen(MYFILE,"w");if(fp==NULL)return1;constchar*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);return0;}

2. mystdio.h

#include<stdio.h>#defineNUM1024#defineBUFF_NONE0x1//表示无缓冲    #defineBUFF_LINE0x2//行缓冲    #defineBUFF_ALL0x4//全缓冲    typedefstructMY_FILE{int fd;//文件描述符    int flags;//刷新方法    char outputbuffer[1024];//输出缓冲区    int current;}MY_FILE;    
 MY_FILE *MY_fopen(constchar*path,constchar*mode);//自己写fopen                                                                                                                        
   size_t MY_fwrite(constvoid*ptr, size_t size, size_t nmemb,  MY_FILE *stream);//自己写的fwrite    intMY_fclose(MY_FILE *fp);//自己写的fwrite    intMY_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(constchar*path,constchar*mode)//自己写fopen {int flag=0;if(strcmp(mode,"r")==0)//说明当前使用读方式打开文件
       flag |= O_RDONLY;//读取elseif(strcmp(mode,"w")==0)
      flag |=(O_CREAT | O_WRONLY | O_TRUNC);//创建文件 以写的方式打开文件  清空文件elseif(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)//当前打开文件失败returnNULL;//3.给用户返回MY_FILE对象，需要先进行构建
    MY_FILE*mf=(MY_FILE*)malloc(sizeof(MY_FILE));if(mf==NULL)//申请空间失败{close(fd);//关闭文件                                                                                                                                                                  returnNULL;}// 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(constvoid*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);}elseif(stream->flags & BUFF_LINE){if(stream->outputbuffer[stream->current-1]=='\n')MY_fflush(stream);}else{//TODO}return writen;}intMY_fflush(MY_FILE *fp){assert(fp);
W>int n=write(fp->fd,fp->outputbuffer,fp->current);//将缓冲区中的current个数传入fd中
   fp->current=0;return0;}intMY_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;return0;}