百度360必应搜狗淘宝本站头条
mqtt服务器xftp6mybatiscollectionkeyerrorc#var
当前位置：网站首页 > 热门文章 > 正文

C语言实现动态扩容的string c++动态扩容

bigegpt 2024-10-13 01:25 47 浏览

众所周知，C++ 中的string使用比较方便。关于C++ 中的string源码实现

最近工作中使用C语言，但又苦于没有高效的字符串实现，字符串的拼接和裁剪都比较麻烦，而且每个字符串都需要申请内存，内存的申请和释放也很容易出bug，怎么高效的实现一个不需要处理内存问题并且可以动态扩容进行拼接和裁剪的string呢？

一个好的string应该有以下功能？

  • 创建字符串
  • 删除字符串
  • 尾部追加字符串
  • 头部插入字符串
  • 从尾部删除N个字符
  • 从头部删除N个字符
  • 裁剪字符串
  • 获取字符串长度
  • 获取完整字符串

下面，我们来看看各个功能的实现。

首先定义一个string的句柄，相当于C++中的实例。

  1. struct c_string;
  2. typedef struct c_string c_string_t;

在内部string的实现如下：

  1. // string的初始内存大小
  2. static const size_t c_string_min_size = 32;

  4. struct c_string {
  5. char *str; // 字符串指针
  6. size_t alloced; // 已分配的内存大小
  7. size_t len; // 字符串的实际长度
  8. };

创建字符串：

  1. c_string_t *c_string_create(void) {
  2. c_string_t *cs;

  4. cs = calloc(1, sizeof(*cs));
  5. cs->str = malloc(c_string_min_size);
  6. *cs->str = '\0';
  7. // 初始分配内存大小是32，之后每次以2倍大小扩容
  8. cs->alloced = c_string_min_size;
  9. cs->len = 0;

  11. return cs;
  12. }

销毁字符串：

  1. void c_string_destroy(c_string_t *cs) {
  2. if (cs == NULL) return;
  3. free(cs->str);
  4. free(cs);
  5. }

内部如何扩容呢：

  1. static void c_string_ensure_space(c_string_t *cs, size_t add_len) {
  2. if (cs == NULL || add_len == 0) return;

  4. if (cs->alloced >= cs->len + add_len + 1) return;

  6. while (cs->alloced < cs->len + add_len + 1) {
  7. cs->alloced <<= 1; // 每次以2倍大小扩容
  8. if (cs->alloced == 0) {
  9. // 左移到最后可能会变为0，由于alloced是无符号型，减一则会变成UINT_MAX
  10. cs->alloced--;
  11. }
  12. }
  13. cs->str = realloc(cs->str, cs->alloced);
  14. }

在尾部追加字符串：

  1. void c_string_append_str(c_string_t *cs, const char *str, size_t len) {
  2. if (cs == NULL || str == NULL || *str == '\0') return;

  4. if (len == 0) len = strlen(str);

  6. c_string_ensure_space(cs, len); // 确保内部有足够的空间存储字符串
  7. memmove(cs->str + cs->len, str, len);
  8. cs->len += len;
  9. cs->str[cs->len] = '\0';
  10. }

在尾部追加字符：

  1. void c_string_append_char(c_string_t *cs, char c) {
  2. if (cs == NULL) return;
  3. c_string_ensure_space(cs, 1);
  4. cs->str[cs->len] = c;
  5. cs->len++;
  6. cs->str[cs->len] = '\0';
  7. }

在尾部追加整数：

  1. void c_string_append_int(c_string_t *cs, int val) {
  2. char str[12];

  4. if (cs == NULL) return;

  6. snprintf(str, sizeof(str), "%d", val); // 整数转为字符串
  7. c_string_append_str(cs, str, 0);
  8. }

在头部插入字符串：

  1. void c_string_front_str(c_string_t *cs, const char *str, size_t len) {
  2. if (cs == NULL || str == NULL || *str == '\0') return;

  4. if (len == 0) len = strlen(str);

  6. c_string_ensure_space(cs, len);
  7. memmove(cs->str + len, cs->str, cs->len);
  8. memmove(cs->str, str, len);
  9. cs->len += len;
  10. cs->str[cs->len] = '\0';
  11. }

在头部插入字符：

  1. void c_string_front_char(c_string_t *cs, char c) {
  2. if (cs == NULL) return;
  3. c_string_ensure_space(cs, 1);
  4. memmove(cs->str + 1, cs->str, cs->len);
  5. cs->str[0] = c;
  6. cs->len++;
  7. cs->str[cs->len] = '\0';
  8. }

在头部插入整数：

  1. void c_string_front_int(c_string_t *cs, int val) {
  2. char str[12];

  4. if (cs == NULL) return;

  6. snprintf(str, sizeof(str), "%d", val);
  7. c_string_front_str(cs, str, 0);
  8. }

清空字符串：

  1. void c_string_clear(c_string_t *cs) {
  2. if (cs == NULL) return;
  3. c_string_truncate(cs, 0);
  4. }

裁剪字符串：

  1. void c_string_truncate(c_string_t *cs, size_t len) {
  2. if (cs == NULL || len >= cs->len) return;

  4. cs->len = len;
  5. cs->str[cs->len] = '\0';
  6. }

删除头部的N个字符：

  1. void c_string_drop_begin(c_string_t *cs, size_t len) {
  2. if (cs == NULL || len == 0) return;

  4. if (len >= cs->len) {
  5. c_string_clear(cs);
  6. return;
  7. }

  9. cs->len -= len;
  10. memmove(cs->str, cs->str + len, cs->len + 1);
  11. }

删除尾部的N个字符：

  1. void c_string_drop_end(c_string_t *cs, size_t len) {
  2. if (cs == NULL || len == 0) return;

  4. if (len >= cs->len) {
  5. c_string_clear(cs);
  6. return;
  7. }
  8. cs->len -= len;
  9. cs->str[cs->len] = '\0';
  10. }

获取字符串的长度：

  1. size_t c_string_len(const c_string_t *cs) {
  2. if (cs == NULL) return 0;
  3. return cs->len;
  4. }

返回字符串指针，使用的是内部的内存：

  1. const char *c_string_peek(const c_string_t *cs) {
  2. if (cs == NULL) return NULL;
  3. return cs->str;
  4. }

重新分配一块内存存储字符串返回：

  1. char *c_string_dump(const c_string_t *cs, size_t *len) {
  2. char *out;

  4. if (cs == NULL) return NULL;

  6. if (len != NULL) *len = cs->len;
  7. out = malloc(cs->len + 1);
  8. memcpy(out, cs->str, cs->len + 1);
  9. return out;
  10. }

测试代码如下：

  1. int main() {
  2. c_string_t *cs = c_string_create();
  3. c_string_append_str(cs, "123", 0);
  4. c_string_append_char(cs, '4');
  5. c_string_append_int(cs, 5);
  6. printf("%s \n", c_string_peek(cs));
  7. c_string_front_str(cs, "789", 0);
  8. printf("%s \n", c_string_peek(cs));
  9. c_string_drop_begin(cs, 2);
  10. printf("%s \n", c_string_peek(cs));
  11. c_string_drop_end(cs, 2);
  12. printf("%s \n", c_string_peek(cs));
  13. c_string_destroy(cs);
  14. return 0;
  15. }

输出：

12345
78912345
912345
9123

完整代码如下：头文件：

  1. #include <stddef.h>

  3. struct c_string;
  4. typedef struct c_string c_string_t;

  6. c_string_t *c_string_create(void);

  8. void c_string_destroy(c_string_t *cs);

  10. void c_string_append_str(c_string_t *cs, const char *str, size_t len);

  12. void c_string_append_char(c_string_t *cs, char c);

  14. void c_string_append_int(c_string_t *cs, int val);

  16. void c_string_front_str(c_string_t *cs, const char *str, size_t len);

  18. void c_string_front_char(c_string_t *cs, char c);

  20. void c_string_front_int(c_string_t *cs, int val);

  22. void c_string_clear(c_string_t *cs);

  24. void c_string_truncate(c_string_t *cs, size_t len);

  26. void c_string_drop_begin(c_string_t *cs, size_t len);

  28. void c_string_drop_end(c_string_t *cs, size_t len);

  30. size_t c_string_len(const c_string_t *cs);

  32. const char *c_string_peek(const c_string_t *cs);

  34. char *c_string_dump(const c_string_t *cs, size_t *len);

源文件：

  1. #include <ctype.h>
  2. #include <stdbool.h>
  3. #include <stdlib.h>
  4. #include <stdio.h>
  5. #include <string.h>

  7. static const size_t c_string_min_size = 32;

  9. struct c_string {
  10. char *str;
  11. size_t alloced;
  12. size_t len;
  13. };

  15. c_string_t *c_string_create(void) {
  16. c_string_t *cs;

  18. cs = calloc(1, sizeof(*cs));
  19. cs->str = malloc(c_string_min_size);
  20. *cs->str = '\0';
  21. cs->alloced = c_string_min_size;
  22. cs->len = 0;

  24. return cs;
  25. }

  27. void c_string_destroy(c_string_t *cs) {
  28. if (cs == NULL) return;
  29. free(cs->str);
  30. free(cs);
  31. }

  33. static void c_string_ensure_space(c_string_t *cs, size_t add_len) {
  34. if (cs == NULL || add_len == 0) return;

  36. if (cs->alloced >= cs->len + add_len + 1) return;

  38. while (cs->alloced < cs->len + add_len + 1) {
  39. cs->alloced <<= 1;
  40. if (cs->alloced == 0) {
  41. cs->alloced--;
  42. }
  43. }
  44. cs->str = realloc(cs->str, cs->alloced);
  45. }

  47. void c_string_append_str(c_string_t *cs, const char *str, size_t len) {
  48. if (cs == NULL || str == NULL || *str == '\0') return;

  50. if (len == 0) len = strlen(str);

  52. c_string_ensure_space(cs, len);
  53. memmove(cs->str + cs->len, str, len);
  54. cs->len += len;
  55. cs->str[cs->len] = '\0';
  56. }

  58. void c_string_append_char(c_string_t *cs, char c) {
  59. if (cs == NULL) return;
  60. c_string_ensure_space(cs, 1);
  61. cs->str[cs->len] = c;
  62. cs->len++;
  63. cs->str[cs->len] = '\0';
  64. }

  66. void c_string_append_int(c_string_t *cs, int val) {
  67. char str[12];

  69. if (cs == NULL) return;

  71. snprintf(str, sizeof(str), "%d", val);
  72. c_string_append_str(cs, str, 0);
  73. }

  75. void c_string_front_str(c_string_t *cs, const char *str, size_t len) {
  76. if (cs == NULL || str == NULL || *str == '\0') return;

  78. if (len == 0) len = strlen(str);

  80. c_string_ensure_space(cs, len);
  81. memmove(cs->str + len, cs->str, cs->len);
  82. memmove(cs->str, str, len);
  83. cs->len += len;
  84. cs->str[cs->len] = '\0';
  85. }

  87. void c_string_front_char(c_string_t *cs, char c) {
  88. if (cs == NULL) return;
  89. c_string_ensure_space(cs, 1);
  90. memmove(cs->str + 1, cs->str, cs->len);
  91. cs->str[0] = c;
  92. cs->len++;
  93. cs->str[cs->len] = '\0';
  94. }

  96. void c_string_front_int(c_string_t *cs, int val) {
  97. char str[12];

  99. if (cs == NULL) return;

  101. snprintf(str, sizeof(str), "%d", val);
  102. c_string_front_str(cs, str, 0);
  103. }

  105. void c_string_clear(c_string_t *cs) {
  106. if (cs == NULL) return;
  107. c_string_truncate(cs, 0);
  108. }

  110. void c_string_truncate(c_string_t *cs, size_t len) {
  111. if (cs == NULL || len >= cs->len) return;

  113. cs->len = len;
  114. cs->str[cs->len] = '\0';
  115. }

  117. void c_string_drop_begin(c_string_t *cs, size_t len) {
  118. if (cs == NULL || len == 0) return;

  120. if (len >= cs->len) {
  121. c_string_clear(cs);
  122. return;
  123. }

  125. cs->len -= len;
  126. /* +1 to move the NULL. */
  127. memmove(cs->str, cs->str + len, cs->len + 1);
  128. }

  130. void c_string_drop_end(c_string_t *cs, size_t len) {
  131. if (cs == NULL || len == 0) return;

  133. if (len >= cs->len) {
  134. c_string_clear(cs);
  135. return;
  136. }
  137. cs->len -= len;
  138. cs->str[cs->len] = '\0';
  139. }

  141. size_t c_string_len(const c_string_t *cs) {
  142. if (cs == NULL) return 0;
  143. return cs->len;
  144. }

  146. const char *c_string_peek(const c_string_t *cs) {
  147. if (cs == NULL) return NULL;
  148. return cs->str;
  149. }

  151. char *c_string_dump(const c_string_t *cs, size_t *len) {
  152. char *out;

  154. if (cs == NULL) return NULL;

  156. if (len != NULL) *len = cs->len;
  157. out = malloc(cs->len + 1);
  158. memcpy(out, cs->str, cs->len + 1);
  159. return out;
  160. }

相关推荐

得物可观测平台架构升级:基于GreptimeDB的全新监控体系实践

一、摘要在前端可观测分析场景中，需要实时观测并处理多地、多环境的运行情况，以保障Web应用和移动端的可用性与性能。传统方案往往依赖代理Agent→消息队列→流计算引擎→OLAP存储...

warm-flow新春版:网关直连和流程图重构

本期主要解决了网关直连和流程图重构，可以自此之后可支持各种复杂的网关混合、多网关直连使用。-新增Ruoyi-Vue-Plus优秀开源集成案例更新日志[feat]导入、导出和保存等新增json格式支持...

扣子空间体验报告

在数字化时代，智能工具的应用正不断拓展到我们工作和生活的各个角落。从任务规划到项目执行，再到任务管理，作者深入探讨了这款工具在不同场景下的表现和潜力。通过具体的应用实例，文章展示了扣子空间如何帮助用户...

spider-flow:开源的可视化方式定义爬虫方案

spider-flow简介spider-flow是一个爬虫平台，以可视化推拽方式定义爬取流程，无需代码即可实现一个爬虫服务。spider-flow特性支持css选择器、正则提取支持JSON/XML格式...

solon-flow 你好世界!

solon-flow是一个基础级的流处理引擎（可用于业务规则、决策处理、计算编排、流程审批等......）。提供有“开放式”驱动定制支持，像jdbc有mysql或pgsql等驱动，可...

新一代开源爬虫平台:SpiderFlow

SpiderFlow：新一代爬虫平台，以图形化方式定义爬虫流程，不写代码即可完成爬虫。-精选真开源，释放新价值。概览Spider-Flow是一个开源的、面向所有用户的Web端爬虫构建平台，它使用Ja...

通过 SQL 训练机器学习模型的引擎

关注薪资待遇的同学应该知道，机器学习相关的岗位工资普遍偏高啊。同时随着各种通用机器学习框架的出现，机器学习的门槛也在逐渐降低，训练一个简单的机器学习模型变得不那么难。但是不得不承认对于一些数据相关的工...

鼠须管输入法rime for Mac

鼠须管输入法forMac是一款十分新颖的跨平台输入法软件，全名是中州韵输入法引擎，鼠须管输入法mac版不仅仅是一个输入法，而是一个输入法算法框架。Rime的基础架构十分精良，一套算法支持了拼音、...

Go语言 1.20 版本正式发布:新版详细介绍

Go1.20简介最新的Go版本1.20在Go1.19发布六个月后发布。它的大部分更改都在工具链、运行时和库的实现中。一如既往，该版本保持了Go1的兼容性承诺。我们期望几乎所...

iOS 10平台SpriteKit新特性之Tile Maps(上)

简介苹果公司在WWDC2016大会上向人们展示了一大批新的好东西。其中之一就是SpriteKitTileEditor。这款工具易于上手，而且看起来速度特别快。在本教程中，你将了解关于TileE...

程序员简历例句—范例Java、Python、C++模板

个人简介通用简介：有良好的代码风格，通过添加注释提高代码可读性，注重代码质量，研读过XXX，XXX等多个开源项目源码从而学习增强代码的健壮性与扩展性。具备良好的代码编程习惯及文档编写能力，参与多个高...

Telerik UI for iOS Q3 2015正式发布

近日，TelerikUIforiOS正式发布了Q32015。新版本新增对XCode7、Swift2.0和iOS9的支持，同时还新增了对数轴、不连续的日期时间轴等；改进TKDataPoin...

ios使用ijkplayer+nginx进行视频直播

上两节，我们讲到使用nginx和ngixn的rtmp模块搭建直播的服务器，接着我们讲解了在Android使用ijkplayer来作为我们的视频直播播放器，整个过程中，需要注意的就是ijlplayer编...

IOS技术分享|iOS快速生成开发文档(一)

前言对于开发人员而言，文档的作用不言而喻。文档不仅可以提高软件开发效率，还能便于以后的软件开发、使用和维护。本文主要讲述Objective-C快速生成开发文档工具appledoc。简介apple...

macOS下配置VS Code C++开发环境

本文介绍在苹果macOS操作系统下，配置VisualStudioCode的C/C++开发环境的过程，本环境使用Clang/LLVM编译器和调试器。一、前置条件本文默认前置条件是，您的开发设备已...

一周热门
最近发表
标签列表