C 语言字符串处理函数实现合集

左手的ㄟ右手 2022-08-01 02:51 214阅读 0赞

其中包括：strcpy(char \*, char \*),strncpy();strcat();strncat();strcmp();strncmp();strchr();strrchr();strlen();

strdup();strspn();strpbrk();strtok(); memset();memcpy();memmove();memcmp();memscan();strstr();

\_strupr\_();\_strlen\_();\_strsplit\_();\_hex2dec\_();\_str2hex\_();\_str2dec\_();

**\[cpp\]**  [view plain][] [copy][view plain]

1.  /\*=========================================================================  
2.    工程名称：C语言

**\[cpp\]**  [view plain][] [copy][view plain]

1.  组成文件：string\_lib.c  
2.  功能描述：常用C库函数的C实现  
3.  程序分析：  
4.  维护记录：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  =========================================================================\*/  
2.    
3.  **char** \* \_\_\_strtok = NULL;  
4.    
5.    
6.  **char** \* strcpy(**char** \* dest,**const** **char** \*src)  
7.  \{  
8.      **char** \*tmp = dest;  
9.    
10.     **while** ((\*dest++ = \*src++) != '\\0')  
11.         /\* nothing \*/;  
12.     **return** tmp;  
13. \}  
14.   
15.   
16.   
17. **char** \* strncpy(**char** \* dest,**const** **char** \*src,**size\_t** count)  
18. \{  
19.     **char** \*tmp = dest;  
20.   
21.     **while** (count-- && (\*dest++ = \*src++) != '\\0')  
22.         /\* nothing \*/;  
23.   
24.     **return** tmp;  
25. \}  
26.   
27.   
28.   
29. **char** \* strcat(**char** \* dest, **const** **char** \* src)  
30. \{  
31.     **char** \*tmp = dest;  
32.   
33.     **while** (\*dest)  
34.         dest++;  
35.     **while** ((\*dest++ = \*src++) != '\\0')  
36.         ;  
37.     **return** tmp;  
38. \}  
39.   
40.   
41.   
42. **char** \* strncat(**char** \*dest, **const** **char** \*src, **size\_t** count)  
43. \{  
44.     **char** \*tmp = dest;  
45.   
46.     **if** (count)   
47.     \{  
48.         **while** (\*dest)  
49.             dest++;  
50.         **while** ((\*dest++ = \*src++))   
51.         \{  
52.             **if** (--count == 0)   
53.             \{  
54.                 \*dest = '\\0';  
55.                 **break**;  
56.             \}  
57.         \}  
58.     \}  
59.     **return** tmp;  
60. \}  
61.   
62.   
63. **int** strcmp(**char** \*s1, **char** \*s2)  
64. \{  
65.     **while**(\*s1 && \*s2)  
66.     \{  
67.         **if**(\*s1 - \*s2)  
68.             **return** (\*s1 - \*s2);  
69.         s1++;  
70.         s2++;  
71.     \}  
72.     **if**(\*s1 != 0)  
73.         **return** 1;  
74.     **else**  
75.         **return** -1;  
76.     **return** 0;  
77. \}  
78.   
79.   
80. **int** strncmp(**char** \*s1, **char** \*s2, **int** len)  
81. \{  
82.     **while**(len--)  
83.     \{  
84.         **if**(\*s1 && \*s2)  
85.         \{  
86.             **if**(\*s1 - \*s2)  
87.                 **return** (\*s1 - \*s2);  
88.             s1++;  
89.             s2++;  
90.         \}  
91.         **else**  
92.         \{  
93.             **if**(\*s1 || \*s2)  
94.                 **return**(\*s1? \*s1: \*s2);  
95.         \}  
96.     \}  
97.     **return** 0;  
98. \}  
99.   
100.   
101. **char** \* strchr(**const** **char** \* s, **int** c)  
102. \{  
103.     **for**(; \*s != (**char**) c; ++s)  
104.         **if** (\*s == '\\0')  
105.             **return** NULL;  
106.     **return** (**char** \*) s;  
107. \}  
108.   
109.   
110. **char** \* strrchr(**const** **char** \* s, **int** c)  
111. \{  
112.        **const** **char** \*p = s + strlen(s);  
113.        **do**   
114.        \{  
115.                 **if** (\*p == (**char**)c)  
116.             **return** (**char** \*)p;  
117.        \}   
118.        **while** (--p >= s);  
119.        **return** NULL;  
120. \}  
121.   
122.   
123. **size\_t** strlen(**const** **char** \* s)  
124. \{  
125.     **const** **char** \*sc;  
126.   
127.     **for** (sc = s; \*sc != '\\0'; ++sc)  
128.         /\* nothing \*/;  
129.     **return** sc - s;  
130. \}  
131.   
132.   
133. **char** \* strdup(**const** **char** \*s)  
134. \{  
135.     **char** \***new**;  
136.   
137.     **if** ( (s == NULL) || ((**new** = malloc (strlen(s) + 1)) == NULL) )  
138.      \{  
139.         **return** NULL;  
140.     \}  
141.   
142.     strcpy (**new**, s);  
143.     **return** **new**;  
144. \}  
145.   
146.   
147. **size\_t** strspn(**const** **char** \*s, **const** **char** \*accept)  
148. \{  
149.     **const** **char** \*p;  
150.     **const** **char** \*a;  
151.     **size\_t** count = 0;  
152.   
153.     **for** (p = s; \*p != '\\0'; ++p)   
154.     \{  
155.         **for** (a = accept; \*a != '\\0'; ++a)   
156.         \{  
157.             **if** (\*p == \*a)  
158.                 **break**;  
159.         \}  
160.         **if** (\*a == '\\0')  
161.             **return** count;  
162.               
163.         ++count;  
164.     \}  
165.   
166.     **return** count;  
167. \}  
168.   
169.   
170. **char** \* strpbrk(**const** **char** \* cs,**const** **char** \* ct)  
171. \{  
172.     **const** **char** \*sc1,\*sc2;  
173.   
174.     **for**( sc1 = cs; \*sc1 != '\\0'; ++sc1)   
175.     \{  
176.         **for**( sc2 = ct; \*sc2 != '\\0'; ++sc2)   
177.         \{  
178.             **if** (\*sc1 == \*sc2)  
179.                 **return** (**char** \*) sc1;  
180.         \}  
181.     \}  
182.     **return** NULL;  
183. \}  
184.   
185.   
186. **char** \* strtok(**char** \* s,**const** **char** \* ct)  
187. \{  
188.     **char** \*sbegin, \*send;  
189.   
190.     sbegin  = s ? s : \_\_\_strtok;  
191.     **if** (!sbegin)   
192.     \{  
193.         **return** NULL;  
194.     \}  
195.     sbegin += strspn(sbegin,ct);  
196.     **if** (\*sbegin == '\\0')   
197.     \{  
198.         \_\_\_strtok = NULL;  
199.         **return**( NULL );  
200.     \}  
201.     send = strpbrk( sbegin, ct);  
202.     **if** (send && \*send != '\\0')  
203.         \*send++ = '\\0';  
204.     \_\_\_strtok = send;  
205.     **return** (sbegin);  
206. \}  
207.   
208.   
209. **void** \* memset(**void** \* s,**char** c,**size\_t** count)  
210. \{  
211.     **char** \*xs = (**char** \*) s;  
212.   
213.     **while** (count--)  
214.         \*xs++ = c;  
215.   
216.     **return** s;  
217. \}  
218.   
219.   
220. **void** \* memcpy(**void** \* dest,**const** **void** \*src,**size\_t** count)  
221. \{  
222.     **char** \*tmp = (**char** \*) dest, \*s = (**char** \*) src;  
223.   
224.     **while** (count--)  
225.         \*tmp++ = \*s++;  
226.   
227.     **return** dest;  
228. \}  
229.   
230.   
231. **void** \* memmove(**void** \* dest,**const** **void** \*src,**size\_t** count)  
232. \{  
233.     **char** \*tmp, \*s;  
234.   
235.     **if** (dest <= src)   
236.     \{  
237.         tmp = (**char** \*) dest;  
238.         s = (**char** \*) src;  
239.         **while** (count--)  
240.             \*tmp++ = \*s++;  
241.     \}  
242.     **else**   
243.     \{  
244.         tmp = (**char** \*) dest + count;  
245.         s = (**char** \*) src + count;  
246.         **while** (count--)  
247.             \*--tmp = \*--s;  
248.     \}  
249.   
250.     **return** dest;  
251. \}  
252.   
253.   
254. **int** memcmp(**const** **void** \* cs,**const** **void** \* ct,**size\_t** count)  
255. \{  
256.     **const** unsigned **char** \*su1, \*su2;  
257.     **signed** **char** res = 0;  
258.   
259.     **for**( su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)  
260.         **if** ((res = \*su1 - \*su2) != 0)  
261.             **break**;  
262.     **return** res;  
263. \}  
264.   
265.   
266. /\* 
267.  \* find the first occurrence of byte 'c', or 1 past the area if none 
268.  \*/  
269. **void** \* memscan(**void** \* addr, **int** c, **size\_t** size)  
270. \{  
271.     unsigned **char** \* p = (unsigned **char** \*) addr;  
272.   
273.     **while** (size) \{  
274.         **if** (\*p == c)  
275.             **return** (**void** \*) p;  
276.         p++;  
277.         size--;  
278.     \}  
279.     **return** (**void** \*) p;  
280. \}  
281.   
282.   
283. **char** \* strstr(**const** **char** \* s1,**const** **char** \* s2)  
284. \{  
285.     **int** l1, l2;  
286.   
287.     l2 = strlen(s2);  
288.     **if** (!l2)  
289.         **return** (**char** \*) s1;  
290.     l1 = strlen(s1);  
291.     **while** (l1 >= l2)   
292.     \{  
293.         l1--;  
294.         **if** (!memcmp(s1,s2,l2))  
295.             **return** (**char** \*) s1;  
296.         s1++;  
297.     \}  
298.     **return** NULL;  
299. \}  
300.   
301. //=============================================================  
302. // 语法格式：    char \*\_strupr\_(char \*Str)  
303. // 实现功能：    将字符串转换为全大写  
304. // 参数：      Str -   输入字符串首地址  
305. // 返回值：     输出字符串首地址  
306. // 注意:      该程序将直接修改原始字符串  
307. //=============================================================  
308. **char** \*\_strupr\_(**char** \*Str)  
309. \{  
310.     **char** \*cp;  
311.     cp = Str;  
312.     **while** (\*cp != 0)  
313.     \{  
314.         **if** (\*cp >= 'a' && \*cp <= 'z' )  
315.         \{  
316.             \*cp -=  'a' - 'A';  
317.         \}  
318.         cp++;  
319.     \}  
320.     **return** Str;  
321. \}  
322.   
323. //=============================================================  
324. // 语法格式：    int \_strlen\_(char \*s)  
325. // 实现功能：    求取字符串长度  
326. // 参数：      s   -   输入字符串首地址  
327. // 返回值：     字符串长度  
328. //=============================================================  
329. **int** \_strlen\_(**char** \*s)  
330. \{  
331.     **int** i = 0;  
332.     **while**(\*s)  
333.     \{  
334.         i++;  
335.         s++;  
336.     \}  
337.     **return** i;  
338. \}  
339.   
340.   
341. //=============================================================  
342. // 语法格式：    int \_strsplit\_(char \*sour, char \*splstr, char \*dest\[\])  
343. // 实现功能：    字符串分割  
344. // 参数：      sour    -   原始字符串首地址  
345. //              splstr  -   分割字符串  
346. //              dest\[\]  -   分割之后的每个字符串的首地址  
347. // 返回值：     分割之后的字符串数量  
348. //=============================================================  
349. **int** \_strsplit\_(**char** \*sour, **char** \*splstr, **char** \*dest\[\])  
350. \{  
351.     **int** i = 0;  
352.     **int** len;  
353.     **char** \*cp;  
354.     **if**(\*splstr == 0)  
355.         **return** 0;  
356.   
357.     cp = sour;  
358.   
359.     dest\[i\] = cp;  
360.     len = \_strlen\_(splstr);  
361.     **while**(\*sour)  
362.     \{  
363.         **if**(\*sour == \*splstr)  
364.         \{  
365.             **if**(\_strncmp\_(sour, splstr, \_strlen\_(splstr)) == 0)  
366.             \{  
367.                 i++;  
368.                 sour += len - 1;  
369.                 \*cp++ = 0;  
370.                 dest\[i\] = cp;  
371.             \}  
372.         \}  
373.         **else** cp++;  
374.        sour++;  
375.     \}  
376.     **return** (i + 1);  
377. \}  
378.   
379. //=============================================================  
380. // 语法格式：    unsigned int \_hex2dec\_(unsigned int Binary)  
381. // 实现功能：    二进制转BCD码(仅转换输入数据的低16bit)  
382. // 参数：      Binary  -   输入数据  
383. // 返回值：     BCD码  
384. //=============================================================  
385. unsigned **int** \_hex2dec\_(unsigned **int** Binary)  
386. \{  
387.     unsigned **int** ulRet = 0;  
388.     Binary &= 0xffff;  
389.     **while**(Binary >= 10000)  
390.     \{  
391.         ulRet += 10000;  
392.         Binary -= 10000;  
393.     \}  
394.     **while**(Binary >= 1000)  
395.     \{  
396.         ulRet += 0x1000;  
397.         Binary -= 1000;  
398.     \}  
399.     **while**(Binary >= 100)  
400.     \{  
401.         ulRet += 0x0100;  
402.         Binary -= 100;  
403.     \}  
404.     **while**(Binary >= 10)  
405.     \{  
406.         ulRet += 0x0010;  
407.         Binary -= 10;  
408.     \}  
409.     ulRet += Binary;  
410.     **return** (ulRet);  
411. \}  
412.   
413. //=============================================================  
414. // 语法格式：    int \_str2hex\_(char \*s)  
415. // 实现功能：    将一个字符串转换为十六进制数据  
416. // 参数：      s   -   输入字符串  
417. // 返回值：     字符串代表的十六进制数据  
418. //=============================================================  
419. **int** \_str2hex\_(**char** \*s)  
420. \{  
421.     **int** Ret = 0;  
422.     s = \_strupr\_(s);  
423.     **if**((s\[0\] != '0') || (s\[1\] != 'X'))  
424.         **return** 0;  
425.     s += 2;  
426.     **while**(\*s)  
427.     \{  
428.         Ret <<= 4;  
429.         **if**((\*s >= '0') && (\*s <= '9'))  
430.             Ret += ((**int**)\*s - '0');  
431.         **else** **if**((\*s >= 'A') && (\*s <= 'Z'))  
432.             Ret += ((**int**)\*s - 'A' + 0x0a);  
433.         **else**  
434.             **return** 0;  
435.         s++;  
436.     \}  
437.     **return** Ret;  
438. \}  
439.   
440. //=============================================================  
441. // 语法格式：    int \_str2dec\_(char \*s)  
442. // 实现功能：    将一个字符串转换为十进制数据  
443. // 参数：      s   -   输入字符串  
444. // 返回值：     字符串代表的十进制数据  
445. //=============================================================  
446. **int** \_str2dec\_(**char** \*s)  
447. \{  
448.     **int** Ret, Flag = 0;  
449.     Ret = 0;  
450.     **if**(\*s == '-')  
451.     \{  
452.         Flag = 1;  
453.         s++;  
454.     \}  
455.     **while**(\*s)  
456.     \{  
457.         **if**((\*s < '0') || (\*s > '9'))  
458.             **return** 0;  
459.         Ret = Ret \* 10 + (**int**)(\*s - '0');  
460.         s++;  
461.     \}  
462.     **if**(Flag)  
463.         Ret \*= -1;  
464.     **return** Ret;  
465. \}

[view plain]: http://blog.csdn.net/txgc0/article/details/8302153#