C字符串处理函数的实现

from http://andylin02.iteye.com/blog/583037
2010.01

Cpp代码  

1. C字符串处理函数的实现（Linux）  
2. #include <stddef.h>  
3. char * ___strtok = NULL;  
4.   
5. char * strcpy(char * dest,const char *src)  
6. {  
7.     char *tmp = dest;  
8.   
9.     while ((*dest++ = *src++) != '\0')  
10.         /* nothing */;  
11.         return tmp;  
12. }  
13.   
14. char * strncpy(char * dest,const char *src,size_t count)  
15. {  
16.     char *tmp = dest;  
17.   
18.     while (count-- && (*dest++ = *src++) != '\0')  
19.         /* nothing */;  
20.   
21.         return tmp;  
22. }  
23.   
24. char * strcat(char * dest, const char * src)  
25. {  
26.     char *tmp = dest;  
27.   
28.     while (*dest)  
29.         dest++;  
30.     while ((*dest++ = *src++) != '\0')  
31.         ;  
32.     return tmp;  
33. }  
34.   
35. char * strncat(char *dest, const char *src, size_t count)  
36. {  
37.     char *tmp = dest;  
38.     if (count) {  
39.         while (*dest)  
40.             dest++;  
41.         while ((*dest++ = *src++)) {  
42.             if (--count == 0)  
43.                 break;  
44.         }  
45.     }  
46.   
47.     return tmp;  
48. }  
49. int strcmp(const char * cs,const char * ct)  
50. {  
51.     register signed char __res;  
52.   
53.     while (1) {  
54.         if ((__res = *cs - *ct++) != 0 || !*cs++)  /*is !*cs++ necessary? incase more cmp*/  
55.             break;  
56.     }  
57.   
58.     return __res;  
59. }  
60.   
61. int strncmp(const char * cs,const char * ct,size_t count)  
62. {  
63.     register signed char __res = 0;  
64.   
65.     while (count) {  
66.         if ((__res = *cs - *ct++) != 0 || !*cs++)  
67.             break;  
68.         count--;  
69.     }  
70.   
71.     return __res;  
72. }  
73.   
74. char * strchr(const char * s,char c)  
75. {  
76.     for(; *s != c; ++s)  
77.         if (*s == '\0')  
78.             return NULL;  
79.     return (char *) s;  
80. }  
81.   
82. size_t strlen(const char * s)  
83. {  
84.     const char *sc;  
85.   
86.     for (sc = s; *sc != '\0'; ++sc)  
87.         /* nothing */;  
88.         return sc - s;  
89. }  
90.   
91. size_t strnlen(const char * s, size_t count)  
92. {  
93.     const char *sc;  
94.   
95.     for (sc = s; *sc != '\0' && count--; ++sc)  
96.         /* nothing */;  
97.         return sc - s;  
98. }  
99.   
100. size_t strspn(const char *s, const char *accept)  
101. {  
102.     const char *p;  
103.     const char *a;  
104.     size_t count = 0;  
105.   
106.     for (p = s; *p != '\0'; ++p) {  
107.         for (a = accept; *a != '\0'; ++a) {  
108.             if (*p == *a)  
109.                 break;  
110.         }  
111.         if (*a == '\0')  
112.             return count;  
113.         ++count;  
114.     }  
115.   
116.     return count;  
117. }  
118.   
119. char * strpbrk(const char * cs,const char * ct)  
120. {  
121.     const char *sc1,*sc2;  
122.   
123.     for( sc1 = cs; *sc1 != '\0'; ++sc1) {  
124.         for( sc2 = ct; *sc2 != '\0'; ++sc2) {  
125.             if (*sc1 == *sc2)  
126.                 return (char *) sc1;  
127.         }  
128.     }  
129.     return NULL;  
130. }  
131.   
132. char * strtok(char * s,const char * ct)  
133. {  
134.     char *sbegin, *send;  
135.   
136.     sbegin  = s ? s : ___strtok;  
137.     if (!sbegin) {  
138.         return NULL;  
139.     }  
140.     sbegin += strspn(sbegin,ct);  
141.     if (*sbegin == '\0') {  
142.         ___strtok = NULL;  
143.         return( NULL );  
144.     }  
145.     send = strpbrk( sbegin, ct);  
146.     if (send && *send != '\0')  
147.         *send++ = '\0';  
148.     ___strtok = send;  
149.     return (sbegin);  
150. }  
151.   
152. void * memset(void * s,char c,size_t count)  
153. {  
154.     char *xs = (char *) s;  
155.   
156.     while (count--)  
157.         *xs++ = c;  
158.   
159.     return s;  
160. }  
161.   
162. char * bcopy(const char * src, char * dest, int count)  
163. {  
164.     char *tmp = dest;  
165.   
166.     while (count--)  
167.         *tmp++ = *src++;  
168.   
169.     return dest;  
170. }  
171. void * memcpy(void * dest,const void *src,size_t count)  
172. {  
173.     char *tmp = (char *) dest, *s = (char *) src;  
174.   
175.     while (count--)  
176.         *tmp++ = *s++;  
177.   
178.     return dest;  
179. }  
180.   
181. void * memmove(void * dest,const void *src,size_t count)  
182. {  
183.     char *tmp, *s;  
184.   
185.     if (dest <= src) {  
186.         tmp = (char *) dest;  
187.         s = (char *) src;  
188.         while (count--)  
189.             *tmp++ = *s++;  
190.     }  
191.     else {  
192.         tmp = (char *) dest + count;  
193.         s = (char *) src + count;  
194.         while (count--)  
195.             *--tmp = *--s;  /*12345678*/  
196.     }     /*12345678*/  
197.   
198.     return dest;  
199. }  
200.   
201. int memcmp(const void * cs,const void * ct,size_t count)  
202. {  
203.     const unsigned char *su1, *su2;  
204.     signed char res = 0;  
205.   
206.     for( su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)  
207.         if ((res = *su1 - *su2) != 0)  
208.             break;  
209.     return res;  
210. }  
211.   
212. /* 
213. * find the first occurrence of byte 'c', or 1 past the area if none 
214. */  
215. void * memscan(void * addr, unsigned char c, size_t size)  
216. {  
217.     unsigned char * p = (unsigned char *) addr;  
218.   
219.     while (size) {  
220.         if (*p == c)  
221.             return (void *) p;  
222.         p++;  
223.         size--;  
224.     }  
225.     return (void *) p;  
226. }  
227.   
228. void main(void)  
229. {  
230.     return;  
231. }  
232.   
233. 补充strstr  
234. char *  
235. strstr (const char *haystack, const char *needle)  
236. {  
237.     char *result = (char *)NULL;  
238.     if ((haystack != (char *)NULL) && (needle != (char *)NULL))  
239.     {  
240.         register int i;  
241.         int hl = strlen (haystack);  
242.         int nl = strlen (needle);  
243.         for (i = 0; i < (hl - nl); i++)  
244.             if (strncmp (haystack + i, needle, nl) == 0)  
245.             {  
246.                 result = haystack + i;  
247.                 break;  
248.             }  
249.     }  
250.     return (result);  
251. }  
252. 还有 加州大学的：  
253. char *strstr(const  char *string, const  char *substring)  
254. {    
255.     const char  *a,  *b;    
256.   
257.     b = substring;    
258.     if (*b == 0)     
259.     {    
260.         return  (char*)string;    
261.     }    
262.     for( ; *string != 0; string += 1)  
263.     {  
264.         if (*string !=  *b)     
265.         {    
266.             continue;    
267.         }    
268.         a = string;    
269.         while ((*a++ == *b++) && (*b != 0) );  
270.   
271.         if (*b == 0)  
272.         {  
273.             return (char*) string;  
274.         }  
275.         b = substring;  
276.     }  
277. }  
278. 最后是AT&T:  
279. extern char*  
280. strstr(register const char* s1, register const char* s2)  
281. {  
282.     register int        c1;  
283.     register int        c2;  
284.     register const char*    t1;  
285.     register const char*    t2;  
286.     if (s2)  
287.     {  
288.         if (!*s2)  
289.             return (char*)s1;  
290.         c2 = *s2++;  
291.         while (c1 = *s1++)  
292.             if (c1 == c2)  
293.             {  
294.                 t1 = s1;  
295.                 t2 = s2;  
296.                 do  
297.                 {  
298.                     if (!*t2)  
299.                         return (char*)s1 - 1;  
300.                 } while (*t1++ == *t2++);  
301.             }  
302.     }  
303.     return 0;  
304. }  
305. --------------------------------------------------------------------------  
306. http://blog.csdn.net/wzbob/archive/2006/11/10/1377600.aspx  
307. c和汇编实现 一些基本字符串处理函数  
308. 1. 将一个字符串(src)拷贝到另一个字符串(dest)，直到遇到NULL 字符后停止。  
309. char *strcpy (char *dest, const char *src)  
310. {  
311.     _asm  
312.     {  
313.         pushf  
314.             mov esi,src  
315.             mov edi,dest  
316.             cld    
317. l1: lodsb   
318.     stosb    
319.     test al,al   
320.     jne l1   
321.     popf  
322.     }      
323.     return dest;     
324. }  
325.   
326.   
327. 2.拷贝源字符串count 个字节到目的字符串。  
328. char *strncpy (char *dest, const char *src, int count)  
329. {  
330.     _asm{  
331.         pushf  
332.             mov esi,src  
333.             mov edi,dest  
334.             mov ecx,count  
335.             cld    
336. l1: dec ecx   
337.     js l2    
338.     lodsb   
339.     stosb    
340.     test al,al   
341.     jne l1    
342.     rep stosb   
343. l2: popf  
344.     }  
345.     return dest;     
346. }  
347.   
348. 3.将源字符串拷贝到目的字符串的末尾处。  
349. char *strcat (char *dest, const char *src)  
350. {  
351.     _asm {  
352.         pushf  
353.             mov esi,src  
354.             mov edi,dest  
355.             xor al,al  
356.             mov ecx,0xffffffff  
357.             cld  // 清方向位。  
358.             repne scasb    
359.             dec edi    
360. l1: lodsb   
361.     stosb    
362.     test al,al   
363.     jne l1   
364.     popf  
365.     }  
366.     return dest;     
367. }  
368.   
369. 4.将源字符串的count 个字节复制到目的字符串的末尾处，最后添一空字符。  
370. char *strncat (char *dest, const char *src, int count)  
371. {  
372.     _asm {  
373.         pushf  
374.             mov esi,src  
375.             mov edi,dest  
376.             xor al,al  
377.             mov ecx,0xffffffff  
378.             cld    
379.             repne scasb   
380.             dec edi   
381.             mov ecx,count   
382. l1: dec ecx  
383.     js l2   
384.     lodsb    
385.     stosb   
386.     test al,al   
387.     jne l1    
388. l2: xor al,al   
389.     stosb    
390.     popf  
391.     }  
392.     return dest;    
393. }  
394.   
395. 5. 将一个字符串与另一个字符串进行比较。  
396. int strcmp (const char *csrc, const char *ct)  
397. {  
398.     _asm{  
399.         pushf  
400.             mov edi,csrc  
401.             mov esi,ct  
402.             cld    
403. l1: lodsb   
404.     scasb    
405.     jne l2   
406.     test al,al   
407.     jne l1    
408.     xor eax,eax   
409.     jmp l3   
410. l2: mov eax,1   
411.     jl l3    
412.     neg eax   
413. l3: popf  
414.     }  
415. }  
416.   
417. ------------------------------------------------------------------------------------  
418. 1. strlen(),计算字符串长度   
419. int strlen(const char string)   
420. {   
421.     int i=0;   
422.     while(string[i]) i++;   
423.     return i;   
424. }   
425. 2. strcpy(), 字符串拷贝.   
426. char *strcpy(char *destination, const char *source)   
427. {   
428.     while(*destinaton++=*source++);   
429.     return (destination-1);   
430. }   
431. 3. strcat(), 字符串的连接.   
432. char *strcat(char *target,const char *source)   
433. {   
434.     char *original=target;   
435.     while(*target) target++; // Find the end of the string   
436.     while(*target++=*source++);   
437.     return(original);   
438. }   
439. 4. streql(), 判断两个字符串是否相等.   
440. int streql(char *str1,char *str2)   
441. {   
442.     while((*str1==*str2)&&(*str1))   
443.     {   
444.         str1++;   
445.         str2++;   
446.     }   
447.     return((*str1==NULL)&&(*str2==NULL));   
448. }   
449. 5. strchr(), 在字符串中查找某个字符.   
450. char *strchr(const char *string,int letter)   
451. {   
452.     while((*string!=letter)&(*string))   
453.         string++;   
454.     return (string);   
455. }   
456. 6. chrcnt(), 计算某个字符在字符串中出现的次数.   
457. int chrcnt(const char *string,int letter)   
458. {   
459.     int count=0;   
460.     while(*string)   
461.         if(*string==letter)count++;   
462.     return count;   
463. }   
464. 7. strcmp(), 判断两个字符串是否相等.   
465. int strcmp(const char *str1,const char *str2)   
466. {   
467.     while((*str1==*str2)&&(*str1))   
468.     {   
469.         str1++;   
470.         str2++;   
471.     }   
472.     if((*str1==*str2)&&(!*str1)) //Same strings   
473.         return o;   
474.     else if((*str1)&&(!*str2)) //Same but str1 longer   
475.         return -1;   
476.     else if((*str2)&&(!*str1)) //Same but str2 longer   
477.     else   
478.     return((*str1>*str2)?-1:1);   
479. }