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

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

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

众所周知，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. }

相关推荐

当Frida来“敲”门（frida是什么）

0x1渗透测试瓶颈目前，碰到越来越多的大客户都会将核心资产业务集中在统一的APP上，或者对自己比较重要的APP，如自己的主业务，办公APP进行加壳，流量加密，投入了很多精力在移动端的防护上。而现在挖...

服务端性能测试实战3-性能测试脚本开发

前言在前面的两篇文章中，我们分别介绍了性能测试的理论知识以及性能测试计划制定，本篇文章将重点介绍性能测试脚本开发。脚本开发将分为两个阶段：阶段一：了解各个接口的入参、出参，使用Python代码模拟前端...

Springboot整合Apache Ftpserver拓展功能及业务讲解(三)

今日分享每天分享技术实战干货，技术在于积累和收藏，希望可以帮助到您，同时也希望获得您的支持和关注。架构开源地址：https://gitee.com/msxyspringboot整合Ftpserver参...

Linux和Windows下:Python Crypto模块安装方式区别

一、Linux环境下：fromCrypto.SignatureimportPKCS1_v1_5如果导包报错：ImportError:Nomodulenamed'Crypt...

Python 3 加密简介（python des加密解密）

Python3的标准库中是没多少用来解决加密的，不过却有用于处理哈希的库。在这里我们会对其进行一个简单的介绍，但重点会放在两个第三方的软件包：PyCrypto和cryptography上，我...

怎样从零开始编译一个魔兽世界开源服务端Windows

第二章：编译和安装我是艾西，上期我们讲述到编译一个魔兽世界开源服务端环境准备，那么今天跟大家聊聊怎么编译和安装我们直接进入正题（上一章没有看到的小伙伴可以点我主页查看）编译服务端：在D盘新建一个文件夹...

附1-Conda部署安装及基本使用（conda安装教程）

Windows环境安装安装介质下载下载地址：https://www.anaconda.com/products/individual安装Anaconda安装时，选择自定义安装，选择自定义安装路径：配置...

如何配置全世界最小的 MySQL 服务器

配置全世界最小的MySQL服务器——如何在一块IntelEdison为控制板上安装一个MySQL服务器。介绍在我最近的一篇博文中，物联网，消息以及MySQL，我展示了如果Partic...

如何使用Github Action来自动化编译PolarDB-PG数据库

随着PolarDB在国产数据库领域荣膺桂冠并持续获得广泛认可，越来越多的学生和技术爱好者开始关注并涉足这款由阿里巴巴集团倾力打造且性能卓越的关系型云原生数据库。有很多同学想要上手尝试，却卡在了编译数据...

面向NDK开发者的Android 7.0变更（ndk android.mk）

订阅Google官方微信公众号：谷歌开发者。与谷歌一起创造未来！受Android平台其他改进的影响，为了方便加载本机代码，AndroidM和N中的动态链接器对编写整洁且跨平台兼容的本机...

信创改造--人大金仓(Kingbase)数据库安装、备份恢复的问题纪要

问题一：在安装KingbaseES时，安装用户对于安装路径需有“读”、“写”、“执行”的权限。在Linux系统中，需要以非root用户执行安装程序，且该用户要有标准的home目录，您可...

OpenSSH 安全漏洞，修补操作一手掌握

1.漏洞概述近日，国家信息安全漏洞库（CNNVD）收到关于OpenSSH安全漏洞（CNNVD-202407-017、CVE-2024-6387）情况的报送。攻击者可以利用该漏洞在无需认证的情况下，通...

Linux:lsof命令详解（linux lsof命令详解）

介绍欢迎来到这篇博客。在这篇博客中，我们将学习Unix/Linux系统上的lsof命令行工具。命令行工具是您使用CLI（命令行界面）而不是GUI（图形用户界面）运行的程序或工具。lsoflsof代表&...

幻隐说固态第一期:固态硬盘接口类别

前排声明所有信息来源于网络收集，如有错误请评论区指出更正。废话不多说，目前固态硬盘接口按速度由慢到快分有这几类：SATA、mSATA、SATAExpress、PCI-E、m.2、u.2。下面我们来...

新品轰炸 影驰SSD多款产品登Computex

分享泡泡网SSD固态硬盘频道6月6日台北电脑展作为全球第二、亚洲最大的3C/IT产业链专业展，吸引了众多IT厂商和全球各地媒体的热烈关注，全球存储新势力—影驰，也积极参与其中，为广大玩家朋友带来了...

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