project1:设计一个 C 语言的动态扩容缓冲区

已于 2023-12-04 20:12:02 修改
阅读量278 收藏
点赞数 3
文章标签： c语言 开发语言 linux
于 2023-01-04 18:47:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74111699/article/details/128552118
版权

project1:设计一个 C 语言的动态扩容缓冲区

文章目录


在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

事实上，在很多优秀项目都会去封装一种接口，如
redis,git。现在你的目标是重新造一遍在轮子（belong
to you!）：

这个缓冲区类的定义就免费送给你们啦：

struct strbuf {
  int len;     //当前缓冲区（字符串）长度
  int alloc;   //当前缓冲区（字符串）容量
  char *buf;   //缓冲区（字符串）
};

在这里插入图片描述

任务正式开始！

详细讲解放在代码中

partA

在这里插入图片描述

//初始化 sb 结构体，容量为 alloc
void strbuf_init(struct strbuf *sb, size_t alloc) {
    sb->buf = (char *) malloc(sizeof(char) * (alloc + 1));
    //不能用. sb并非结构名称
    sb->len = 0;
    sb->alloc = alloc;
}

//将字符串填充到 sb 中，长度为 len, 容量为 alloc
void strbuf_attach(struct strbuf *sb, void *str, size_t len, size_t alloc) {
    sb->len = len;
    sb->alloc = alloc;
    //   int i,slen;
    //   slen=strlen(str);
    //   for(i=0;i<slen;i++){
    //     sb->buf[i]=str[i];
    //   }
    //   sb->buf[sb->len]='\0';
    sb->buf = (char *) str;
    //强制类型转换，buf为指向字符的指针
}

//释放 sb 结构体的内存
void strbuf_release(struct strbuf *sb) {
    free(sb->buf);
    //free(sb);
}

//交换两个 strbuf
void strbuf_swap(struct strbuf *a, struct strbuf *b) {
    int num1;
    char *num2;

    num1 = a->len;
    a->len = b->len;
    b->len = num1;

    num1 = a->alloc;
    a->alloc = b->alloc;
    b->alloc = num1;

    num2 = a->buf;
    a->buf = b->buf;
    b->buf = num2;
    //结构体不像数组，是可以直接赋值的
    //所以此段代码可以简化为如下形式：
   // struct strbuf c=*a;
   //*a=*b;
   //*b=c;
}

//将 sb 中的原始内存取出，并将 sz 设置为其 alloc 大小
char *strbuf_detach(struct strbuf *sb, size_t *sz) {
    *sz = sb->alloc;
    return sb->buf;
    //返回字符串
}

//比较两个 strbuf 的内存是否相同
int strbuf_cmp(const struct strbuf *first, const struct strbuf *second) {
    if (first->len > second->len) {
        return 1;
    } else if (first->len < second->len) {
        return -1;
    } else {
        return 0;
        //返回0证明相同
    }
}

//清空sb
void strbuf_reset(struct strbuf *sb) {
    for(int i=0;i<sb->len;i++)
    {
    sb->buf[i]='\0';
    }
    sb->len=0;
}

partB

在这里插入图片描述

//确保在 len 之后 strbuf 中至少有 extra 个字节的空闲空间可用
void strbuf_grow(struct strbuf *sb, size_t extra) {
    sb->buf = (char *) realloc(sb->buf, sb->len + extra + 1);
    if (sb->alloc < sb->len + extra + 1) {
        sb->alloc = sb->len + extra + 1;
    }
    

> realloc:有时我们觉得我们用malloc，calloc函数申请的动态内存空间太大了，
> 有时觉得申请的空间太小了，为了合理使用内存，我们要对内存的大小做灵活的调整，
>  那么realloc函数就可以做到控制动态内存开辟的大小。
>  realloc函数原型：
>  void* realloc(void* memblock, size_t size)
>  size_t size指的是New size in bytes,新的字节数，注意不是增加的字节数，而是新开辟的那块内存空间的字节数，返回值为调整之后的内存的起始地址


}

//向 sb 追加长度为 len 的数据 data
void strbuf_add(struct strbuf *sb, const void *data, size_t len) {
    if(len==0)
    {
	    return;//特殊情况没有数据
    }
    //判断是否扩容
    if(sb->len+len>=sb->alloc)
    {
        sb->buf=(char *)realloc(sb->buf,sb->len+len+1);
        sb->alloc=sb->len+len+1;
    }
    memcpy(sb->buf+sb->len,data,len);
    sb->len+=len;
    sb->buf[sb->len]='\0';
}

> memcpy函数是C/C++语言中的一个用于内存复制的函数，声明在 string.h 中（C++是 cstring）。其原型是：
> 
> void *memcpy(void *destin, void *source, unsigned n);
> 作用是：以source指向的地址为起点，将连续的n个字节数据，复制到以destin指向的地址为起点的内存中。
> 函数有三个参数，第一个是目标地址，第二个是源地址，第三个是数据长度。
> 
> 使用memcpy函数时，需要注意：
> 
> 数据长度（第三个参数）的单位是字节（1byte = 8bit）。 注意该函数有一个返回值，类型是void*，是一个指向destin的指针。

//向 sb 追加一个字符 c
void strbuf_addch(struct strbuf *sb, int c) {
  // if(sb->alloc==0){
  //   sb->alloc=2;
  // }else{
  //   if (sb->alloc < sb->len+1) {
  //       sb->alloc = sb->alloc * 2;
  //   }
  // }
  //   sb->len += 1;
  //   sb->buf = (char *) realloc(sb->buf, sb->alloc);
  //   sb->buf[sb->len-1] = c;
  //   sb->buf[sb->len] = '\0';
  if(sb->alloc==0){
        sb->alloc=2;//特殊情况
    }
    else{
        if(sb->alloc<=sb->len+2)
        {
            sb->alloc*=2;
        }
    }
  sb->buf=(char*)realloc(sb->buf,(sb->alloc));
  sb->len+=1;
  sb->buf[sb->len-1]=c;
  sb->buf[sb->len]='\0';
}

//向 sb 追加一个字符串 s
void strbuf_addstr(struct strbuf *sb, const char *s) {
    // while (sb->alloc < sb->len + strlen(s)+1) {
    //     sb->alloc *= 2;
    // }
    // sb->buf = (char *) realloc(sb->buf, sb->len + strlen(s) + 1);
    // int len=strlen(s);
    // sb->len+=len;
    // memcpy(sb->buf,s,len);
    strbuf_add(sb,s,strlen(s));
    //sb->buf[sb->len]='\0';
}

//向一个 sb 追加另一个 strbuf的数据
void strbuf_addbuf(struct strbuf *sb, const struct strbuf *sb2) {
    strbuf_addstr(sb, sb2->buf);
}

//设置 sb 的长度 len
void strbuf_setlen(struct strbuf *sb, size_t len) {
    // if (sb->alloc < len + 1) {
    //     sb->alloc = len + 1;
    // }
    sb->len = len;
    //sb->buf = (char *) realloc(sb->buf, sb->len);
    sb->buf[sb->len] = '\0';
}

//计算 sb 目前仍可以向后追加的字符串长度
size_t strbuf_avail(const struct strbuf *sb) {
    return sb->alloc - sb->len - 1;
    //-1非常重要，不要忘记'\0'
}

//向 sb 内存坐标为 pos 位置插入长度为 len 的数据 data
void strbuf_insert(struct strbuf *sb, size_t pos, const void *data, size_t len) {
    sb->len += len;
    if (sb->alloc < sb->len + 1) {
        sb->alloc = sb->len + 1;
    }
    sb->buf = (char *) realloc(sb->buf, sb->alloc + 1);
    char *p = (char *) malloc(sizeof(char) * (sb->len));//引入新变量
 
    // char *t = (char *) malloc(sizeof(char) * (sb->len));
    // char *s = (char *) malloc(sizeof(char) * (sb->len));
    // int cnt=0;
    // t = sb->buf;
    // while (t <= sb->buf + pos) {
    //     *s = *t;
    //     t++;
    //     s++;
    // }
    // s[pos+1]='\0';
    // while (*t != '\0') {
    //     *p = *t;
    //     t++;
    //     p++;
    //     cnt++;
    // }
    // p[cnt+1]='\0';
    // strcat(s, (const char *) data);
    // strcat(s, p);
    // sb->buf=s;
    strcpy(p,sb->buf+pos);
    strcpy(sb->buf+pos,(const char*)data);
    strcat(sb->buf,p);
    free(p);//不free造成内存泄漏！
}

partC

在这里插入图片描述

//去除 sb 缓冲区左端的所有 空格，tab, '\t'
void strbuf_ltrim(struct strbuf *sb) {
    char *s = sb->buf;//, *p = sb->buf;
    while (*s != '\0' && (*s == ' ' || *s == '\t')) {
        s++;
        sb->len--;
    }
    memmove(sb->buf,s,sb->len);
    

> memmove()函数用于：移动内存块
> 函数声明：void * memmove ( void * destination, const void * source, size_t num );
> 从source复制num个字符到destination中

    // while (*s != '\0') {
    //     *p++ = *s++;
    // }
    // p[sb->len] = '\0';
    // sb->buf = p;
}

//去除 sb 缓冲区右端的所有 空格，tab, '\t'
void strbuf_rtrim(struct strbuf *sb) {
    while (sb->buf[sb->len-1] == ' ' || sb->buf[sb->len-1] == '\t') {
        sb->len--;
    }
    sb->buf[sb->len] = '\0';
}

// 删除 sb 缓冲区从 pos 坐标长度为 len 的内容
void strbuf_remove(struct strbuf *sb, size_t pos, size_t len) {
    // char *p = (char *) malloc(sizeof(char) * (sb->len));
    // char *t = (char *) malloc(sizeof(char) * (sb->len));
    // t = sb->buf + pos + len;
    // strcpy(p, sb->buf + pos + len);
    // sb->len = pos + len;
    // while (t != sb->buf + pos - 1) {
    //     sb->len--;
    //     t--;
    // }
    // sb->buf[sb->len] = '\0';
    // strcat(sb->buf, p);
    // sb->len -= len;
    memmove(sb->buf+pos,sb->buf+pos+len,sb->len-len-pos);
    sb->len=sb->len-len;
}

partD

在这里插入图片描述

//sb 增长 hint ? hint : 8192 大小， 然后将文件描述符为 fd 的所有文件内容追加到 sb 中
ssize_t strbuf_read(struct strbuf *sb, int fd, size_t hint) {
    sb->buf = (char *) realloc(sb->buf, (sb->alloc += hint ? hint : 8192));
    sb->alloc += hint ? hint : 8192;
    FILE *fp = fdopen(fd, "r");
    if (fp != NULL) {
        char ch;
        while ((ch = fgetc(fp)) != EOF) {
            sb->buf[sb->len++] = ch;
        }
        sb->buf[sb->len] = '\0';
    }
    return sb->len;
}

//将 将文件句柄为 fp 的一行内容（抛弃换行符）读取到 sb   检查长度是否超过缓冲区
int strbuf_getline(struct strbuf *sb, FILE *fp) {
        int ch;
        //int count=0;
        while ((ch = fgetc(fp)) != EOF) {
          if( (ch == '\n')||(feof(fp)!=0)){
            break;
          }
          if((strbuf_avail(sb)>=1)){
            strbuf_addch(sb,ch);
            
          }else if((strbuf_avail(sb)<1)){
            sb->buf = (char *) realloc(sb->buf, sb->alloc+1);
            strbuf_addch(sb,ch);
            // sb->alloc+=1;
            // sb->buf[sb->len++] = ch;
          }
            // sb->buf = (char *) realloc(sb->buf, sb->alloc);
            // sb->buf[sb->len++] = ch;
        }
        //sb->buf[sb->len] = '\0';
    return sb->len;
}

无信用挑战练习

在这里插入图片描述

//将长度为 len 的字符串 str 根据切割字符 terminator 切成多个 strbuf,并从结果返回，max 可以用来限定最大切割数量。
//返回 struct strbuf 的指针数组，数组的最后元素为 NULL
struct strbuf **strbuf_split_buf(const char *str, size_t len, int terminator, int max) {
    struct strbuf **buf_link = (struct strbuf **) malloc(sizeof(struct strbuf *) * (max+1));
    const char *end=str+len;
    const char *head=str;
    const char *p;
    int count=0;//计数不能超过max
    while(*head==terminator)
      head++;
    //跳过开头的目标字符
    for (p=head;p<=end;p++) {
    //在指针没有指到末尾时一直向前移动
        if (*p==terminator||p==end) {
        //遇到切割字符开始切割
            int len_tmp;
            len_tmp=p-head;
            buf_link[count]=(strbuf*)malloc(sizeof(strbuf));//!非常重要，动态分配内存
            buf_link[count]->len=len_tmp;
            buf_link[count]->alloc=len_tmp+1;//为'\0'留下空间
            buf_link[count]->buf=(char *)malloc(sizeof(char)*(len_tmp+1));//for '\0'
            memcpy(buf_link[count]->buf,head,len_tmp);
            //内存复制函数
            buf_link[count]->buf[len_tmp]='\0';
            count++;
            //buf_link[count++]->buf[len_tmp]='\0';
            while (*p==terminator&&p<=end){
              p++;//找到下一次开始的地方
            }
            head=p;//切割完又重新开始，寻找下一个切割字符
        }
        if (count==max)
            break;
    }
    buf_link[count]=NULL;
    return buf_link;
}


//target_str : 目标字符串，str : 前缀字符串，strlen : target_str 长度 ，前缀相同返回 true 失败返回 false
bool strbuf_begin_judge(char *target_str, const char *str, int len) {
    int i;
    // for (i = 0; i < strlen(str); i++) {
    //   if(len==0){
    //     return true;
    //   }
    //   if(strlen(str)>len){
    //     return false;
    //   }
    //     if (target_str[i] != str[i]) {
    //         //flag=1;
    //         return false;
    //     }
    // }
    // // if(flag==0){
    // //   return true;
    // // }
    // return true;
    if (len == 0)
        return true;//特殊情况
    if (strlen(str) > len)
        return false;//粗略判断
    for (int i = 0; i < strlen(str); i++) {
        if (str[i] != target_str[i]) {
            return false;
        }
    }
    //不同返回false,跳出for循环后则返回true
    return true;
}


//target_str : 目标字符串，begin : 开始下标，end 结束下标。
//len : target_buf的长度，参数不合法返回 NULL. 下标从0开始，[begin, end)区间。
char *strbuf_get_mid_buf(char *target_buf, int begin, int end, int len) {
    if (begin < 0 || end < 0 || end > len || len < 0) {
        return NULL;
    } else {
        char *p = (char *) malloc(sizeof(char *) * (end - begin + 1));
        int i = begin, j = 0;
        for (i = begin, j = 0; i < end; i++, j++) {
            *(p + j) = *(target_buf + i);
        }
        //memcpy(p, target_buf + begin, end - begin);
        p[end - begin] = '\0';
        return p;
    }
}
谢谢我现在很bug
关注
Apache Flink®极简教程: 架构及原理 Stateful Computations over Data Streams
程序员光剑
12-28 9297
Flink 极简教程: 架构及原理 Apache Flink® — Stateful Computations over Data Streams关键词分布式流处理分布式计算引擎All s...
Flink 极简教程: 架构及原理 Apache Flink® — Stateful Computations over Data Streams
程序员光剑
12-27 9282
Flink 极简教程: 架构及原理 Apache Flink® — Stateful Computations over Data Streams 关键词 分布式流处理 分布式计算引擎 All streaming use cases Event-driven Applications Stream & Batch Analytics Data Pipelines &a...
Project1：设计一个 C 语言的动态扩容缓冲区strbuf
Yan__Ran的博客
01-18 788
终于成功merge了： 任务内容 根据目标自行定义填充所给出的API，所给缓冲区类的定义为： struct strbuf { int len; //当前缓冲区（字符串）长度 int alloc; //当前缓冲区（字符串）容量 char *buf; //缓冲区（字符串） }; 共五个板块： 以下为我的实现： #include <stdio.h> #include <string.h> #include <std...
【Linux内核】内存管理——malloc的内存分配
Ethan-Code's blog
10-06 2270
使用malloc时，会从两个区分配内存，分别是 文件映射区 和 堆区。 当申请的内存小于 128K 时，会通过 brk() 系统调用，从堆区分配内存。 当申请的内存大于 128K 时，会通过 mmap() 系统调用，从文件映射区分配内存。 下面讲两种分配方式的区别。
Linux文件缓冲区
超哥的专栏
04-16 1592
1. 数据缓冲区C 程序员经常使用动态分配的缓冲区（通过调用 malloc() / free() 函数）在函数之间传递数据2. 为什么需要缓冲首先在若干字符作为一个块传输比逐个发送字符耗费的时间少。其次如果你输入有误。就可以使用您的键盘更改功能来修正错误。并且最终按下回车，就可以发送正确的输入3. 缓冲区的分类缓冲分为两类，完全缓冲和行缓冲1.对于完全缓冲来说，缓冲区满时，缓冲区会被清空。此时缓冲区
malloc申请最大运行内存
一堆土的博客
11-17 2701
贴一个在Windows平台下，关于malloc申请最大运行内存的代码，运行很费时间，可能是一个byte去读，效率比较低吧。 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; unsigned maximum = 0; int main() { unsigned blocksize[] = { 1024 * 1024, 1024, 1 }; ...
javase学习笔记，学习时间一个月，发布笔记进度1/3
m0_60726300的博客
04-10 1866
1. Java基本语法 1.1 语言概述 1.1.1 整体语言概述 1.1.2 Java语言概述 1.1.2.1 基础常识 软件：即一系列按照特定顺序组织的计算机数据和指令集合。分为系统软件和应用软件 系统软件：Windows，mac os，linux，unix，android，ios，… 应用软件：word，ppt，画图板 人机交互方式：图形化界面vs命令行方式 应用程序=算法+数据结构 1.1.2.2 计算机语言的发展迭代史 第一代：机器语言 第二代：汇编语言 第三代：高级语言 面向过程：C，P
一个程序员的成长之路
weixin_35713159的博客
04-13 1382
equals一般比较对象内容是否相等，而==比较两者的栈中保存的对象堆地址值是否相等，即是否指向同一个对象，equals在object中就存在，如不重写的话两者没有区别，重写时一般使用hashcode方法结合，比较相等首先判断hashcode是否相等，相等再进行真实值的比较，大大降低比较时间，最多两次即可判断。原因：在一个范围中的浮点数个数不是有限的，存在精度问题，如果要进行比较，使用BigDecimal并使用BigDecimal提供的对象方法进行计算，构造时使用String作为入参防止丢失精度。
基于AT89C51单片机的红外防盗报警器设计
runweipa的博客
06-09 1583
基于AT89C51单片机的红外防盗报警器设计
c语言中内存缓冲区的建立，并在缓冲区中动态分配内存
04-03
通过文件中的mm.h文件，编写c程序时，把mm.h文件包含在头文件中，就可以调用里面的提供的函数，建立内存缓冲区，并可以通过mm.h中实现的函数对这个内存缓冲区进行动态的分配内存。
malloc能分配多大内存
yellow的博客
04-07 4536
《程序员自我修养》中的一段代码，贴出来看看效果
malloc 最大可以分配多大内存
SearchLife的专栏
12-24 8239
 引用：http://topic.csdn.net/u/20080801/01/2fa67f5e-3d2a-4d58-8b3d-a1fd36988458.html要做高速图像处理，用到大缓存，好像malloc做到644MB就上顶了，645MB就会获得空指针 malloc的上限到底是多少啊？ 系统：内存2GB，XP sp2系统，BDS 2007 w/ sp1问
关于设计一个 C 语言的动态扩容缓冲区
weixin_62017112的博客
01-21 804
日月不肯迟，四时相催迫。 这个项目的条条例例都是小组的学姐学长的写出来的呐（不得不感叹小组学长的智慧吖），我也只是按照要求写了每个API,写的磕磕盼盼，但是呢，学到了不少知识，现在分享个大家。 先来了解了解做这个项目需要掌握什么知识叭 知识点 字符串。 面向对象的 C 语言设计。 动态内存分配。 Linux File API。 getline。 一.首先看缓冲区类的定义 struct strbuf { int len; //当前缓冲区（字符串）长度 int all..
C语言：结构体
2302_80978287的博客
09-15 616
结构体是由用户自己定义（设计）的数据类型。其实就是各种信息的打包。比如说，每个学生都有学号、姓名和成绩，100个学生就有100份这种数据，打包起来整合就会方便很多。struct [结构体名]{成员列表int score;//别忘记分号int year;int month;int day;int score;//嵌套（1）先定义结构体，再定义结构体变量struct Student{ //定义结构体类型int score;int main()//定义两个结构体变量。
低级编程语言和高级编程语言
最新发布
C_User1024的博客
09-16 1161
低级编程语言,并不是简单的编程语言,而是写起来很费事的编程语言,如所有编程语言的"祖宗":汇编语言,写起来极其麻烦,说不定一个 int a=1;它就得写好几行,甚至十几行这样麻烦的编程语言为什么还没消失那,因为它效率高.
【LINUX】SHELL贪吃蛇
09-11 499
Show()#Mapdo;;;esacdone#Snakefor ((i=0;i++))doecho "*"done#Foodecho "0"dodoneMove();;;;esacArrayMovethenthenthenthenfithen。
【Linux】：信号与信号产生
Yikefore的博客
09-12 890
信号的基本概念、对信号的理解、信号的多种产生方式以及核心转储的详细介绍！
Linux FTP服务问题排查
09-15 364
最近linux虚拟机重启之后发现，FTP服务总是不正常，工具无法连接。
CCPM缓冲区尺寸设计：未确知测度理论应用
"本文主要探讨了基于未确知测度理论的CCPM（Critical Chain Project Management，关键链项目管理）缓冲区尺寸设计方法。作者王晓波通过考虑工程项目中的工序风险偏好程度、执行时间不确定性程度、复杂性程度和开工...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值