【创作赢红包】| 【Linux】 基础IO——自己实现文件接口FILE

testfile: main.c mystdio.c    
   gcc -o $@ $^    
.PHONY:clean    
clean:    
   rm -f testfile

#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;    
}    

#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);//自己实现的缓冲区    

#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;
  }