您当前的位置:首页 > 电脑百科 > 程序开发 > 语言 > C/C++/C#

C语言实现动态扩容的string

时间:2023-04-02 12:17:52  来源:今日头条  作者:Chadwik

众所周知,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;
  3.  
  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;
  3.  
  4. cs = calloc(1, sizeof(*cs));
  5. cs->str = malloc(c_string_min_size);
  6. *cs->str = '';
  7. // 初始分配内存大小是32,之后每次以2倍大小扩容
  8. cs->alloced = c_string_min_size;
  9. cs->len = 0;
  10.  
  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;
  3.  
  4. if (cs->alloced >= cs->len + add_len + 1) return;
  5.  
  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 == '') return;
  3.  
  4. if (len == 0) len = strlen(str);
  5.  
  6. c_string_ensure_space(cs, len); // 确保内部有足够的空间存储字符串
  7. memmove(cs->str + cs->len, str, len);
  8. cs->len += len;
  9. cs->str[cs->len] = '';
  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] = '';
  7. }

在尾部追加整数:

  1. void c_string_append_int(c_string_t *cs, int val) {
  2. char str[12];
  3.  
  4. if (cs == NULL) return;
  5.  
  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 == '') return;
  3.  
  4. if (len == 0) len = strlen(str);
  5.  
  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] = '';
  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] = '';
  8. }

在头部插入整数:

  1. void c_string_front_int(c_string_t *cs, int val) {
  2. char str[12];
  3.  
  4. if (cs == NULL) return;
  5.  
  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;
  3.  
  4. cs->len = len;
  5. cs->str[cs->len] = '';
  6. }

删除头部的N个字符:

  1. void c_string_drop_begin(c_string_t *cs, size_t len) {
  2. if (cs == NULL || len == 0) return;
  3.  
  4. if (len >= cs->len) {
  5. c_string_clear(cs);
  6. return;
  7. }
  8.  
  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;
  3.  
  4. if (len >= cs->len) {
  5. c_string_clear(cs);
  6. return;
  7. }
  8. cs->len -= len;
  9. cs->str[cs->len] = '';
  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;
  3.  
  4. if (cs == NULL) return NULL;
  5.  
  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>
  2.  
  3. struct c_string;
  4. typedef struct c_string c_string_t;
  5.  
  6. c_string_t *c_string_create(void);
  7.  
  8. void c_string_destroy(c_string_t *cs);
  9.  
  10. void c_string_append_str(c_string_t *cs, const char *str, size_t len);
  11.  
  12. void c_string_append_char(c_string_t *cs, char c);
  13.  
  14. void c_string_append_int(c_string_t *cs, int val);
  15.  
  16. void c_string_front_str(c_string_t *cs, const char *str, size_t len);
  17.  
  18. void c_string_front_char(c_string_t *cs, char c);
  19.  
  20. void c_string_front_int(c_string_t *cs, int val);
  21.  
  22. void c_string_clear(c_string_t *cs);
  23.  
  24. void c_string_truncate(c_string_t *cs, size_t len);
  25.  
  26. void c_string_drop_begin(c_string_t *cs, size_t len);
  27.  
  28. void c_string_drop_end(c_string_t *cs, size_t len);
  29.  
  30. size_t c_string_len(const c_string_t *cs);
  31.  
  32. const char *c_string_peek(const c_string_t *cs);
  33.  
  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>
  6.  
  7. static const size_t c_string_min_size = 32;
  8.  
  9. struct c_string {
  10. char *str;
  11. size_t alloced;
  12. size_t len;
  13. };
  14.  
  15. c_string_t *c_string_create(void) {
  16. c_string_t *cs;
  17.  
  18. cs = calloc(1, sizeof(*cs));
  19. cs->str = malloc(c_string_min_size);
  20. *cs->str = '';
  21. cs->alloced = c_string_min_size;
  22. cs->len = 0;
  23.  
  24. return cs;
  25. }
  26.  
  27. void c_string_destroy(c_string_t *cs) {
  28. if (cs == NULL) return;
  29. free(cs->str);
  30. free(cs);
  31. }
  32.  
  33. static void c_string_ensure_space(c_string_t *cs, size_t add_len) {
  34. if (cs == NULL || add_len == 0) return;
  35.  
  36. if (cs->alloced >= cs->len + add_len + 1) return;
  37.  
  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. }
  46.  
  47. void c_string_append_str(c_string_t *cs, const char *str, size_t len) {
  48. if (cs == NULL || str == NULL || *str == '') return;
  49.  
  50. if (len == 0) len = strlen(str);
  51.  
  52. c_string_ensure_space(cs, len);
  53. memmove(cs->str + cs->len, str, len);
  54. cs->len += len;
  55. cs->str[cs->len] = '';
  56. }
  57.  
  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] = '';
  64. }
  65.  
  66. void c_string_append_int(c_string_t *cs, int val) {
  67. char str[12];
  68.  
  69. if (cs == NULL) return;
  70.  
  71. snprintf(str, sizeof(str), "%d", val);
  72. c_string_append_str(cs, str, 0);
  73. }
  74.  
  75. void c_string_front_str(c_string_t *cs, const char *str, size_t len) {
  76. if (cs == NULL || str == NULL || *str == '') return;
  77.  
  78. if (len == 0) len = strlen(str);
  79.  
  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] = '';
  85. }
  86.  
  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] = '';
  94. }
  95.  
  96. void c_string_front_int(c_string_t *cs, int val) {
  97. char str[12];
  98.  
  99. if (cs == NULL) return;
  100.  
  101. snprintf(str, sizeof(str), "%d", val);
  102. c_string_front_str(cs, str, 0);
  103. }
  104.  
  105. void c_string_clear(c_string_t *cs) {
  106. if (cs == NULL) return;
  107. c_string_truncate(cs, 0);
  108. }
  109.  
  110. void c_string_truncate(c_string_t *cs, size_t len) {
  111. if (cs == NULL || len >= cs->len) return;
  112.  
  113. cs->len = len;
  114. cs->str[cs->len] = '';
  115. }
  116.  
  117. void c_string_drop_begin(c_string_t *cs, size_t len) {
  118. if (cs == NULL || len == 0) return;
  119.  
  120. if (len >= cs->len) {
  121. c_string_clear(cs);
  122. return;
  123. }
  124.  
  125. cs->len -= len;
  126. /* +1 to move the NULL. */
  127. memmove(cs->str, cs->str + len, cs->len + 1);
  128. }
  129.  
  130. void c_string_drop_end(c_string_t *cs, size_t len) {
  131. if (cs == NULL || len == 0) return;
  132.  
  133. if (len >= cs->len) {
  134. c_string_clear(cs);
  135. return;
  136. }
  137. cs->len -= len;
  138. cs->str[cs->len] = '';
  139. }
  140.  
  141. size_t c_string_len(const c_string_t *cs) {
  142. if (cs == NULL) return 0;
  143. return cs->len;
  144. }
  145.  
  146. const char *c_string_peek(const c_string_t *cs) {
  147. if (cs == NULL) return NULL;
  148. return cs->str;
  149. }
  150.  
  151. char *c_string_dump(const c_string_t *cs, size_t *len) {
  152. char *out;
  153.  
  154. if (cs == NULL) return NULL;
  155.  
  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. }


Tags:C语言   点击:()  评论:()
声明:本站部分内容及图片来自互联网,转载是出于传递更多信息之目的,内容观点仅代表作者本人,不构成投资建议。投资者据此操作,风险自担。如有任何标注错误或版权侵犯请与我们联系,我们将及时更正、删除。
▌相关推荐
C语言中的volatile:变量的易变性和内存访问的优化
概念:在C语言中,volatile是一个关键字,用于告诉编译器变量的值是易变的,可能会在意料之外的情况下发生改变,从而防止编译器对该变量的优化和缓存。volatile关键字用于修饰那些可...【详细内容】
2023-12-31  Search: C语言  点击:(64)  评论:(0)  加入收藏
C语言中的静态变量解析
一、引言在C语言中,变量的存储类别决定了变量在程序中的生命周期和可见性。静态变量是其中一种具有特殊属性的变量,它们在程序的执行过程中具有持久的生命周期,并且仅在其定义...【详细内容】
2023-12-29  Search: C语言  点击:(139)  评论:(0)  加入收藏
C语言变长参数及其陷阱
C 工具变长参数列表这部分解释了旧的 C 风格变长参数列表。了解这些内容很重要,因为你可能会在遗留代码中遇到它们。然而,在新代码中,你应该使用变参模板来实现类型安全的变长...【详细内容】
2023-12-15  Search: C语言  点击:(141)  评论:(0)  加入收藏
C语言代码:数字雨
在我们的日常生活中,雨水是我们经常遇到的一种自然现象。有时候,我们会在雨中漫步,欣赏那美丽的雨景。然而,在计算机世界里,我们如何用代码来模拟这种美丽的雨景呢?本文将通过一个...【详细内容】
2023-11-23  Search: C语言  点击:(155)  评论:(0)  加入收藏
拿捏C语言,就看这一篇!
嵌入式系统是我们日常生活中无处不在的一部分。从智能手机到家用电器,从汽车到医疗设备,嵌入式系统的应用范围广泛且不断增长。C语言是一种高效、简洁、灵活的编程语言,是嵌入...【详细内容】
2023-11-14  Search: C语言  点击:(221)  评论:(0)  加入收藏
Java为什么比C语言更加的受青睐?
Java和C语言都是广泛应用于软件开发领域的编程语言,然而Java在近年来越来越受到开发者的青睐。这主要归因于Java在以下几个方面的优势。跨平台性Java的跨平台性是其最显著的...【详细内容】
2023-11-09  Search: C语言  点击:(337)  评论:(0)  加入收藏
自学C语言,其最恐怖的地方是什么?
今天我们来聊聊关于自学C语言的事。首先得承认,这条路并不容易。学会C语言自学对很多人来说都是个不小的考验。这门编程语言的复杂性和一堆晦涩难懂的概念,让学习过程变得相当...【详细内容】
2023-11-03  Search: C语言  点击:(197)  评论:(0)  加入收藏
比C语言还快20%!Mojo首个大模型开放下载,性能达Python版250倍
明敏 发自 凹非寺量子位 公众号 | QbitAI专为AI而来的新语言Mojo,推理LLaMA2性能比Python提升250倍!比C语言也要快上20%。上周五才开放下载,Mojo这么快就自证实力了。要知道,之...【详细内容】
2023-09-13  Search: C语言  点击:(363)  评论:(0)  加入收藏
为什么C++无法彻底替代C语言?
随着时间的推移,编程语言的发展不断演进,新的工具和技术层出不穷。然而,在这个瞬息万变的编程世界中,有一对老朋友一直在默默地坚守着自己的位置:C 和 C++。这两门编程语言都拥有...【详细内容】
2023-09-11  Search: C语言  点击:(286)  评论:(0)  加入收藏
c语言中的预处理、宏、条件编译
在C程序中,以 # 开头的命令就是预处理命令,这些命令都是放在函数之外,而且一般都放在源文件的前面,如下面的两条命令:#include <stdio.h> #define PI 3.1415926宏可以看做是一些...【详细内容】
2023-09-08  Search: C语言  点击:(327)  评论:(0)  加入收藏
▌简易百科推荐
C++中的外部模板及其在当前编译文件中的实例化
在C++中,模板是一种泛型编程的工具,它允许程序员以一种类型无关的方式编写代码。然而,模板的一个常见问题是它们会导致编译时间增加,特别是在大型项目中,当多个源文件包含相同的...【详细内容】
2024-04-11  鲨鱼编程  微信公众号  Tags:C++   点击:(2)  评论:(0)  加入收藏
C++常见避坑指南
C++ 从入门到放弃?本文主要总结了在C++开发或review过程中常见易出错点做了归纳总结,希望借此能增进大家对C++的了解,减少编程出错,提升工作效率,也可以作为C++开发的避坑攻略。...【详细内容】
2024-04-03  腾讯技术工程    Tags:C++   点击:(5)  评论:(0)  加入收藏
C++ 之父反驳白宫警告:自诞生第一天起,C++ 的目标就一直是提高安全性
整理 | 郑丽媛上个月,美国白宫国家网络主任办公室(ONCD)在一份主题为《回到基础构件:通往安全软件之路》的 19 页 PDF 报告中,呼吁开发人员停止使用容易出现内存安全漏洞的编程语...【详细内容】
2024-03-25    CSDN  Tags:C++   点击:(4)  评论:(0)  加入收藏
八个 C++ 开源项目,帮助初学者进阶成长
通过参与或阅读开源项目的源代码,你可以获得丰富的实践机会。实际的项目代码比简单的教程更具挑战性,可以帮助你深入理解 C++ 的各种概念和技术。1.ThreadPool一个简单的 C++1...【详细内容】
2024-03-22  AI让生活更美好  微信公众号  Tags:C++   点击:(21)  评论:(0)  加入收藏
C# 中15个值得收藏的开源项目推荐
在开源的世界里,C# 编程语言也占有一席之地。这些开源项目涵盖了多个领域,从框架、库到工具,它们为C#开发者提供了丰富的资源和工具,帮助他们更高效地开发、测试和部署应用程序...【详细内容】
2024-03-20  程序员编程日记  微信公众号  Tags:C#   点击:(30)  评论:(0)  加入收藏
C#异步编程:Task.Run vs. async-await,掌握基础与高级用法
概述:C#中的异步编程有两主要方式:Task.Run用于在后台线程执行同步操作,而async-await更适用于清晰表达异步流程。基础用法展示了它们的简单应用,高级用法则演示了它们的结合使...【详细内容】
2024-03-09  架构师老卢  今日头条  Tags:C#   点击:(23)  评论:(0)  加入收藏
C++多线程编程:解锁性能与并发的奥秘
今天我们将深入探讨C++中的多线程编程,揭示多线程如何解锁性能潜力,提高程序的并发性能。什么是多线程?在计算机科学中,多线程是指一个进程(程序的执行实例)中的多个线程同时执行...【详细内容】
2024-02-03     AI让生活更美好  Tags:C++   点击:(69)  评论:(0)  加入收藏
C++代码优化攻略
今天我们将深入探讨C++性能优化的世界。在当今软件开发的浪潮中,高性能的代码是必不可少的。无论是开发桌面应用、移动应用,还是嵌入式系统,性能都是关键。1. 选择合适的数据结...【详细内容】
2024-01-26  AI让生活更美好  微信公众号  Tags:C++   点击:(115)  评论:(0)  加入收藏
C# 线程本地存储为什么线程间值不一样
为什么用 ThreadStatic 标记的字段,只有第一个线程拿到了初始值,其他线程都是默认值,让我能不能帮他解答一下,尼玛,我也不是神仙什么都懂,既然问了,那我试着帮他解答一下,也给后面类...【详细内容】
2024-01-26  一线码农聊技术  微信公众号  Tags:C#   点击:(68)  评论:(0)  加入收藏
C++质数检测器的设计与实现​
质数,作为数学中的一个基本概念,一直以其独特的性质吸引着众多研究者和爱好者。质数是指大于1的自然数中,除了1和它本身以外不再有其他因数的数。在实际应用中,质数检测也扮演着...【详细内容】
2024-01-15  鲨鱼编程  微信公众号  Tags:C++   点击:(115)  评论:(0)  加入收藏
站内最新
站内热门
站内头条