Linux内核中常用字符串函数实现

1. //列举了部分常用的strcpy，strcmp，strcat，strchr，strstr，strpbrk...  
2.   
3.  char *strcpy(char *dest, const char *src)  
4. {  
5.     char *tmp = dest;  
6.   
7.     while ((*dest++ = *src++) != '\0')  
8.         /* nothing */;  
9.     return tmp;  
10. }  
11.   
12. char *strncpy(char *dest, const char *src, size_t count)  
13. {  
14.     char *tmp = dest;  
15.   
16.     while (count) {  
17.         if ((*tmp = *src) != 0)  
18.             src++;  
19.         tmp++;  
20.         count--;  
21.     }  
22.     return dest;  
23. }  
24.   
25. char *strcat(char *dest, const char *src)  
26. {  
27.     char *tmp = dest;  
28.   
29.     while (*dest)  
30.         dest++;  
31.     while ((*dest++ = *src++) != '\0')  
32.         ;  
33.     return tmp;  
34. }  
35.   
36. char *strncat(char *dest, const char *src, size_t count)  
37. {  
38.     char *tmp = dest;  
39.   
40.     if (count) {  
41.         while (*dest)  
42.             dest++;  
43.         while ((*dest++ = *src++) != 0) {  
44.             if (--count == 0) {  
45.                 *dest = '\0';  
46.                 break;  
47.             }  
48.         }  
49.     }  
50.     return tmp;  
51. }  
52.   
53. int strcmp(const char *cs, const char *ct)  
54. {  
55.     signed char __res;  
56.   
57.     while (1) {  
58.         if ((__res = *cs - *ct++) != 0 || !*cs++)  
59.             break;  
60.     }  
61.     return __res;  
62. }  
63.   
64. int strncmp(const char *cs, const char *ct, size_t count)  
65. {  
66.     signed char __res = 0;  
67.   
68.     while (count) {  
69.         if ((__res = *cs - *ct++) != 0 || !*cs++)  
70.             break;  
71.         count--;  
72.     }  
73.     return __res;  
74. }  
75.   
76. char *strchr(const char *s, int c)  
77. {  
78.     for (; *s != (char)c; ++s)  
79.         if (*s == '\0')  
80.             return NULL;  
81.     return (char *)s;  
82. }  
83.   
84. char *strrchr(const char *s, int c)  
85. {  
86.        const char *p = s + strlen(s);  
87.        do {  
88.            if (*p == (char)c)  
89.                return (char *)p;  
90.        } while (--p >= s);  
91.        return NULL;  
92. }  
93.   
94. char *strnchr(const char *s, size_t count, int c)  
95. {  
96.     for (; count-- && *s != '\0'; ++s)  
97.         if (*s == (char)c)  
98.             return (char *)s;  
99.     return NULL;  
100. }  
101.   
102. size_t strlen(const char *s)  
103. {  
104.     const char *sc;  
105.   
106.     for (sc = s; *sc != '\0'; ++sc)  
107.         /* nothing */;  
108.     return sc - s;  
109. }  
110.   
111. char *strpbrk(const char *cs, const char *ct)  
112. {  
113.     const char *sc1, *sc2;  
114.   
115.     for (sc1 = cs; *sc1 != '\0'; ++sc1) {  
116.         for (sc2 = ct; *sc2 != '\0'; ++sc2) {  
117.             if (*sc1 == *sc2)  
118.                 return (char *)sc1;  
119.         }  
120.     }  
121.     return NULL;  
122. }  
123.   
124. void *memcpy(void *dest, const void *src, size_t count)  
125. {  
126.     char *tmp = dest;  
127.     const char *s = src;  
128.   
129.     while (count--)  
130.         *tmp++ = *s++;  
131.     return dest;  
132. }  
133.   
134. int memcmp(const void *cs, const void *ct, size_t count)  
135. {  
136.     const unsigned char *su1, *su2;  
137.     int res = 0;  
138.   
139.     for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)  
140.         if ((res = *su1 - *su2) != 0)  
141.             break;  
142.     return res;  
143. }  
144.   
145. char *strstr(const char *s1, const char *s2)  
146. {  
147.     int l1, l2;  
148.   
149.     l2 = strlen(s2);  
150.     if (!l2)  
151.         return (char *)s1;  
152.     l1 = strlen(s1);  
153.     while (l1 >= l2) {  
154.         l1--;  
155.         if (!memcmp(s1, s2, l2))  
156.             return (char *)s1;  
157.         s1++;  
158.     }  
159.     return NULL;  
160. }  

     来源： http://blog.csdn.net/willib/article/details/38460691