日日操夜夜添-日日操影院-日日草夜夜操-日日干干-精品一区二区三区波多野结衣-精品一区二区三区高清免费不卡

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