C语言实现动态扩容的string（c语言动态内存分配malloc）

众所周知，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 = '\0';
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 == '\0') 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] = '\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];
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 == '\0') 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] = '\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];
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] = '\0';
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] = '\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;
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
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
2. #include
3. #include
4. #include
5. #include
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 = '\0';
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 == '\0') 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] = '\0';
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] = '\0';
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 == '\0') 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] = '\0';
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] = '\0';
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] = '\0';
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] = '\0';
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. }