自己封装一个简单的FILE

已于 2023-05-10 21:49:25 修改
阅读量58 收藏
点赞数
分类专栏： linux 文章标签： linux
于 2023-05-06 22:49:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74075521/article/details/130536977
版权
本文展示了如何创建一个简单的C库，包含自定义的文件操作函数如my_fopen、my_fwrite、my_fflush和my_fclose。这个库使用了一个内部缓冲区来提高效率，减少了对底层IO接口的调用次数。my_fwrite函数考虑了缓冲区满的情况，并根据缓冲策略决定何时刷新。my_fflush用于将缓冲区内容写入文件。整个库的实现加深了对标准C库中FILE结构和缓冲机制的理解。
摘要由CSDN通过智能技术生成

我们学习了系统文件，我们可以对系统接口，模仿库，自己封装一个简单的文件接口，FILE

OK，我们创建文件
在这里插入图片描述
mystdio.h文件内容

   #pragma once                                                                                                    
                                                               
   #include <stdio.h>                                                       
                                                                             
   #define NUM 1024                                                                       
   #define BUFFER_NONE 0x1 // 无缓冲                                               
   #define BUFFER_LINE 0x2 // 行缓冲                                                           
   #define BUFFER_ALL 0x4 // 全缓冲                                                                      
                                                                                               
  typedef struct my_FILE                                                                                 
  {                                                                
    int fd;                                                     
    int flags;                                                                                     
    char outputbuffer[NUM];                                     
    int size;                                                
  }my_FILE;                                                              
                                                                               
  my_FILE* my_fopen(const char* path, const char* mode);                  
  size_t my_fwrite(const void* ptr, size_t size, size_t nmemb, my_FILE* stream);
  int my_fflush(my_FILE* fp);                                                                                      
  int my_fclose(my_FILE* fp);

my_fopen函数

   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_CREAT | O_WRONLY | O_TRUNC);                                               
    else if(strcmp(mode, "a") == 0)                                                         
      flag |= (O_CREAT | O_WRONLY | O_APPEND);                                              
    else                                                                                    
    {                                                                                       
      //还有"a+","w+","r+"就不一一实现了                                                    
    }                                                                                       
                                                                                            
    //打开文件                                                                              
    mode_t m = 0666;                                                                        
    int fd = 0;                                                                             
    if(flag & O_CREAT) // 如设置了创建的选项，调用三参的open                                
      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);//malloc失败了后，要先关闭文件，再返回                                      
      return NULL;                                                                          
    }                                                                                       
                                                                                            
    //初始化对象                                                                            
    mf->fd = fd;
    mf->flags = 0;                                                                            
    mf->flags = BUFFER_LINE;//设置行缓冲                                                    
    memset(mf->outputbuffer, '\0', sizeof(mf->outputbuffer));//初始化缓冲区
  
    //返回打开的文件
    return mf;
  }

fflush函数

  int my_fflush(my_FILE* fp)
  {
    assert(fp);
    
    write(fp->fd, fp->outputbuffer, fp->size);
    fp->size = 0;
    return 0;
  }

fwrite函数

  //库函数的返回值是写入的个数，返回写入的个数比较复杂，我们这里返回写入的字节数
  size_t my_fwrite(const void* ptr, size_t size, size_t nmemb, my_FILE* stream)
  {
    //size是数量，nmemb是类型所占的字节数
    if(stream->size == NUM)//缓冲区满了，直接刷新
      my_fflush(stream);
  
    size_t user_size = size * nmemb; // 用户想要写入的字节
    size_t my_size = NUM - stream->size; // 缓冲区剩余的可写入的字节数
  
    size_t writen = 0;//写入的字节数
    if(my_size >= user_size)
    {
      //剩余空间够，用户想写入多少都直接写入
      memcpy(stream->outputbuffer + stream->size, ptr, user_size);
      stream->size += user_size;
      writen = user_size;
    }
    else
    {
      //剩余空间不够，还剩多少写多少
      memcpy(stream->outputbuffer + stream->size, ptr, my_size);
      stream->size += my_size;
      writen = my_size;
    }
  
    //刷新缓冲区
    if(stream->flags & BUFFER_ALL)
    {
      if(stream->size == NUM)
        my_fflush(stream);
    }
    else if(stream->flags & BUFFER_LINE)
    {
      if(stream->outputbuffer[stream->size - 1] == '\n')
        my_fflush(stream);
    }
 
   return 0;
 }

fclose函数

 int my_fclose(my_FILE* fp)
 {
   assert(fp);
   // 冲刷缓冲区
   if(fp->size > 0)
    my_fflush(fp);
   // 关闭文件
   close(fp->fd);
   // 释放空间
   free(fp);
   // 指针置NULL
   fp = NULL;
 
   return 0;
 }

mystdio.c所有代码

    #include "mystdio.h"
    #include <string.h>
    #include <sys/stat.h>
    #include <sys/types.h>
    #include <fcntl.h>
    #include <malloc.h>
    #include <unistd.h>
    #include <assert.h>
   
    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_CREAT | O_WRONLY | O_TRUNC);                                               
      else if(strcmp(mode, "a") == 0)                                                         
        flag |= (O_CREAT | O_WRONLY | O_APPEND);                                              
      else                                                                                    
      {                                                                                       
        //还有"a+","w+","r+"就不一一实现了                                                    
      }                                                                                       
                                                                                            
      //打开文件                                                                              
      mode_t m = 0666;                                                                        
      int fd = 0;                                                                             
      if(flag & O_CREAT) // 如设置了创建的选项，调用三参的open                                
        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);//malloc失败了后，要先关闭文件，再返回                                      
        return NULL;                                                                          
      }                                                                                       
                                                                                             
       //初始化对象                                                                            
       mf->fd = fd;
       mf->flags = 0;                                                                            
       mf->flags = BUFFER_LINE;//设置行缓冲                                                    
       memset(mf->outputbuffer, '\0', sizeof(mf->outputbuffer));//初始化缓冲区
  
       //返回打开的文件
      return mf;
    }                      

     int my_fflush(my_FILE* fp)
     {
       assert(fp);
    
       write(fp->fd, fp->outputbuffer, fp->size);
       fp->size = 0;
       return 0;
     }

    //库函数的返回值是写入的个数，返回写入的个数比较复杂，我们这里返回写入  的字节数
    size_t my_fwrite(const void* ptr, size_t size, size_t nmemb, my_FILE* stream)
    {
      //size是数量，nmemb是类型所占的字节数
      if(stream->size == NUM)//缓冲区满了，直接刷新
        my_fflush(stream);
  
      size_t user_size = size * nmemb; // 用户想要写入的字节
      size_t my_size = NUM - stream->size; // 缓冲区剩余的可写入的字节数
  
      size_t writen = 0;//写入的字节数
      if(my_size >= user_size)
      {
        //剩余空间够，用户想写入多少都直接写入
        memcpy(stream->outputbuffer + stream->size, ptr, user_size);
        stream->size += user_size;
        writen = user_size;
      }
      else
      {
        //剩余空间不够，还剩多少写多少
        memcpy(stream->outputbuffer + stream->size, ptr, my_size);
        stream->size += my_size;
        writen = my_size;
      }
  
      //刷新缓冲区
      if(stream->flags & BUFFER_ALL)
      {
        if(stream->size == NUM)
          my_fflush(stream);
      }
      else if(stream->flags & BUFFER_LINE)
      {
        if(stream->outputbuffer[stream->size - 1] == '\n')
          my_fflush(stream);
      }
 
     return 0;
   }

fclose函数

 int my_fclose(my_FILE* fp)
 {
   assert(fp);
   // 冲刷缓冲区
   if(fp->size > 0)
    my_fflush(fp);
   // 关闭文件
   close(fp->fd);
   // 释放空间
   free(fp);
   // 指针置NULL
   fp = NULL;
 
   return 0;
 }

为什么要c库中还要有个缓冲区呢？

因为文件写入是要调用IO接口的，调用IO是速度比较慢的，c库中有缓冲区，可以减少IO调用次数，加快速度

OK，以上就是简单的封装的FILE了，相信大家看完了之后，对FILE的理解会更加深刻

_leaf.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java如何把文件封装File对象_Java基础：File文件流
weixin_31446315的博客
02-27 740
概述封装一个磁盘路径字符串，对这个路径可以执行一次操作。可以用来封装文件路径、文件夹路径、不存在的路径。创建对象File(String pathname)通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。举个例子：File file = new File("E:\\testForIO\\test.txt");其余的构造方法：File(File parent, String chi...
封装一个自己的mvc框架
石阳的博客
12-24 5433
1. 首先我们要有一个封装mvc的流程 2. 写入口文件 <?php /* * 入口文件 * 1.定义常量 * 2.加载函数库 * 3.启动框架 * */ define('IMOOC',realpath('./')); //获取的那个前框架所在的目录 define('CORE',IMOOC,'/core'); //框架核心文件所在的目录 define('APP',IMOOC,'
java目录封装File类对象基本用法
gb4215287的博客
06-09 583
java目录封装File类对象基本用法
如何封装一个实用的上传组件
小陈的博客
11-15 1483
为大家准备了一个前端资料包。包含54本，2.57G的前端相关电子书，《前端面试宝典（附答案和解析）》，难点、重点知识视频教程（全套）。有需要的小伙伴，可以点击下方卡片领取，无偿分享。
java如何把文件封装File对象_Java编程IO流中的File对象
weixin_42601608的博客
02-27 564
之前学的IO流都是基础的东西，而且在操作上都仅限于读和取，况且还不是那么的细，所以今天学习的File类对象主要就是能够把文件对象化，并能够轻松的读取或者操作其中的诸如：文件名、创建/修改时间和文件夹路径等等这些细分的功能。请看例子import java.io.File;public class FileDemo {/*** @param args*/public static void main(...
python封装一个requests请求
默金
03-28 1422
python封装一个requests请求 from requests import Session class Api_Request(Session): def api_request(self,url, method, parametric_key, header=None, data=None, file=None) -> dict: if parametric_key=="params": parametric={"params":data}
封装一个图片上传组件的方法
m0_68331234的博客
06-14 1822
封装一个上传图片的组件
简单封装axios
吉屋安的博客
02-24 700
请求拦截器，用于在请求发送前进行处理，比如在请求头中添加 token ，在请求发送之前，如果有需要，可以在请求头中加入认证信息。创建一个名为 instance 的 Axios 实例，配置默认的请求地址和超时时间。封装 POST 请求方法，支持传入请求地址和数据。导出封装好的 GET、POST 和上传文件的方法。封装 GET 请求方法，支持传入请求地址和参数。响应拦截器，用于统一处理后端返回的错误信息。封装上传文件的方法，支持传入请求地址和文件。
自己封装一个文件上传函数（使用axios）
海天酱油zz
11-28 2937
序言 昨天在写博客的个人动态页面，里面涉及到了图片上传。 之前我都是用的别人的插件和elementUI的upload组件。但是现在没法用了。 页面的效果差别有点大，如果改elementUI的样式，会很累。 这时候很愁人啊。（懒啊！） 这是页面开发的效果，很像qq空间的感觉。 一、选型 1、选择1：自己从新写系列。 我参考了（简称xhr）和Fetch 文档地址： XMLHt...
vue2封装一个文件上传的组件
感谢您阅读我的博客，如果您有任何问题或建议，请随时联系我。
03-24 1337
vue2对el-upload进行组件封装
webuploader自己封装的一个闭包插件
12-28
在这个项目中，开发者已经根据WebUploader的基本功能进行了一次封装，创建了一个闭包插件，以简化使用过程。 在HTML文件中，可以看到插件的调用方式和具体的交互设计。通常，WebUploader的使用会涉及到以下几个核心...
php封装一个异常的处理类
12-20
以下是一个简单的自定义异常处理类的例子： ```php class TelException extends Exception { public function errorTel() { $errorMsg = "出错原因：".$this->getMessage()."不是一个合法的电话号码"; $errorMsg...
封装ThinkPHP的一个文件上传方法实例
10-25
在本实例中，我们将深入探讨如何在ThinkPHP框架中封装一个文件上传方法，以实现图片、缩略图和文件的高效上传与管理。 首先，我们要理解封装的意义。封装是面向对象编程的一个核心概念，它允许我们把相关的功能聚合...
Vue封装一个简单轻量的上传文件组件的示例
01-19
一、之前遇到的一些问题 项目中多出有上传文件的需求，使用现有的UI框架实现的过程中，不知道什么原因，总会有一些莫名其妙的bug。比如用某上传组件，明明注明（:multiple=”false”）,可实际上还是能多选，上传的...
linux HBA驱动中scsi_host_template .shost_attrs
最新发布
Wang20122013的博客
08-13 352
scsi_host_template是一个结构体，用于定义SCSI主机（host adapter）的属性和操作。这个模板用于初始化SCSI主机结构体scsi_host_template，它包含了主机的属性、操作函数等。shost_attrs是scsi_host_template结构体中的一个成员，它是一个属性组，用于定义SCSI主机可以支持的属性。每个属性都会有相应的操作函数，这些函数定义了如何读取或写入属性值。例如，一个属性可能有一个show函数来返回当前值，一个store函数来设置新值。
Linux os下借助Qt+libvlc是实现多路拉取摄像头rtsp数据流并实时显示
hanpca的博客
08-13 721
Linux os下 借助Qt+libvlc实现同时拉取多路摄像头的rtsp流解码并显示
如何解码Linux下事件响应工具evtest的时间戳
weixin_44199156的博客
08-08 359
这里放一下原文链接在开发input子系统驱动时，常常会使用evtest工具进行测试。evtest是打印evdev内核事件的工具，它直接从内核设备读取并打印设备描述的带有值和符号名的事件，可以用来调试鼠标、键盘、触摸板等输入设备evtest通常用于在X.org中调试输入设备的问题，evtest提供了内核的处理信息。根据这些信息，可以判断是内核问题还是X.org问题。输出数据中，“type”是input类型，可以是“EV KEY”、“EV SW”、“EV SND”、“EV LED”或数值；
Linux Java服务管理脚本（启动、停止、查看状态）
程序员阿华的博客
08-08 174
Linux Java服务管理脚本（启动、停止、查看状态）
Linux 调试之动态打印
Teminator_的博客
08-08 5531
在 kernel 驱动代码中，使用动态输出是系统内核调试的重要手段之一，printk打印是全局的，只能设置输出等级，而且使用printk每次都要重新编译内核，很不方便。。而动态输出可以在不需要重新编译内核的情况下，方便的打印出内核的 debug 信息。动态输出可以动态选择打开某个内核子系统的输出，可以有选择性地打开某些模块的输出，printk被dev_infodev_dbgdev_err之类的函数代替，dev_xxx函数的本质还是使用printk打印的，只是对printk进行了一层包装。
UE5 封装一个简单的插件DEMO
05-26
好的，下面我来简单介绍一下如何封装一个简单的插件DEMO。 首先，我们需要创建一个新的UE5项目。在这个项目中，我们将创建一个简单的插件，用于在游戏中显示一些文本。 1. 创建插件 在UE5编辑器中，选择File -> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值