其中包括：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_();
1. /*=========================================================================
2. 工程名称：C语言
1. 组成文件：string_lib.c
2. 功能描述：常用C库函数的C实现
3. 程序分析：
4. 维护记录：
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. '\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. 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. '\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. char *) dest;
238. char *) src;
239. while (count--)
240. *tmp++ = *s++;
241. }
242. else
243. {
244. char *) dest + count;
245. 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. 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. '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. 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. int)*s - '0');
431. else if((*s >= 'A') && (*s <= 'Z'))
432. 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. int)(*s - '0');
460. s++;
461. }
462. if(Flag)
463. Ret *= -1;
464. return Ret;
465. }
