字符串库函数strcpy strcmp strstr memcpy memmove等的实现

1. //字符串长度  
2. int strlen(const char *str)     
3. {     
4.     assert(str != NULL);     
5.     int len = 0;     
6.     while (*str ++ != '\0')     
7.         ++ len;     
8.     return len;     
9. }  
10.   
11. //字符串拷贝  
12. char *strcpy(char *to, const char *from)  
13. {  
14.     assert((to != NULL) && (from != NULL));  
15.     char * result = to;  
16.     while( (*to++ = *from++) != '\0')  
17.         NULL;  
18.     return result;         
19. }  
20. //strncpy()，如果from指向的字符个数少于count，则用'\0'补齐  
21. char *strncpy(char *to, const char *from, size_t count)  
22. {  
23.     assert((to != NULL) && (from != NULL));  
24.     char * result = to;  
25.     while(count--)  
26.     {  
27.         if(*from != '\0')  
28.         {  
29.             *to++ = *from++;  
30.         }  
31.         else  
32.         {  
33.             *to++ = '\0';  
34.         }  
35.     }  
36.     return result;         
37. }  
38.   
39. //memcpy(), 拷贝不重叠的内存块   
40. void* memcpy(void* to, const void* from, size_t count)  
41. {  
42.     assert((to != NULL) && (from != NULL));  
43.     void * result = to;  
44.     assert(to < from || (char*)to > (char*)from + count -1);  
45.     while(count--)  
46.     {  
47.        *((char*)to)++ = *((char*)from)++;  
48.     }  
49.     return result;  
50. }  
51.   
52. //memmove(), 拷贝重叠或者是不重叠的内存块   
53. void* memmove(void* to, const void* from, size_t count)  
54. {  
55.     assert((to != NULL) && (from != NULL));  
56.     void * result = to;  
57.     //to与from没有重叠  
58.     if(to < from || (char*)to > (char*)from + count -1)  
59.     {  
60.        while(count--)  
61.        {  
62.            *(char*)to++ = *(char*)from++;  
63.        }  
64.     }  
65.     //to与from有重叠，从后向前move  
66.     else  
67.     {  
68.        to = (char*)to + count -1;  
69.        from = (char*)from + count -1;  
70.        while(count--)  
71.        {  
72.           *(char*)to-- = *(char*)from--;  
73.        }  
74.     }  
75.     return result;  
76. }  
77.   
78. //memset():把指定内存区域的前count个字节设置成字符c  
79. void * memset(void* buffer, int c, size_t count)  
80. {  
81.     assert(buffer != NULL);  
82.     void * result = buffer;  
83.     while(count--)  
84.         *(char*)buffer++ = (char)c;  
85.     return result;  
86. }  
87.   
88. //查找字符串s中首次出现字符c的位置     
89. char *strchr(const char *str, int c)     
90. {     
91.     assert(str != NULL);     
92.     for (; *str != (char)c; ++ str)     
93.         if (*str == '\0')     
94.             return NULL;     
95.         return str;     
96. }     
97.   
98. //字符串比较  
99. int strcmp(const char *s, const char *t)     
100. {     
101.     assert(s != NULL && t != NULL);     
102.     while (*s && *t && *s == *t)     
103.     {     
104.         ++ s;     
105.         ++ t;     
106.     }     
107.     return (*s - *t);     
108. }     
109.   
110. int strncmp(const char *s, const char *t, unsigned int count)     
111. {     
112.     assert((s != NULL) && (t != NULL));     
113.     while (*s && *t && *s == *t && count --)     
114.     {     
115.         ++ s;     
116.         ++ t;     
117.     }     
118.     return (*s - *t);     
119. }  
120.   
121. //字符串连接  
122. char *strcat(char *strDes, const char *strSrc)     
123. {     
124.     assert((strDes != NULL) && (strSrc != NULL));     
125.     char *address = strDes;     
126.     while (*strDes != '\0')     
127.         ++ strDes;     
128.     while ((*strDes ++ = *strSrc ++) != '\0')     
129.         NULL;     
130.     return address;     
131. }  
132.   
133. char *strncat(char *strDes, const char *strSrc, unsigned int count)     
134. {     
135.     assert((strDes != NULL) && (strSrc != NULL));     
136.     char *address = strDes;     
137.     while (*strDes != '\0')     
138.         ++ strDes;     
139.     while (count -- && *strSrc != '\0' )     
140.         *strDes ++ = *strSrc ++;     
141.     *strDes = '\0';     
142.     return address;     
143. }     
144.   
145. //查找字符串第一次出现的位置  
146. char *strstr(const char *strSrc, const char *str)     
147. {     
148.     assert(strSrc != NULL && str != NULL);     
149.     const char *s = strSrc;     
150.     const char *t = str;     
151.     for (; *strSrc != '\0'; ++ strSrc)     
152.     {     
153.         for (s = strSrc, t = str; *t != '\0' && *s == *t; ++s, ++t)     
154.             NULL;     
155.         if (*t == '\0')     
156.             return (char *) strSrc;     
157.     }     
158.     return NULL;     
159. }   
160.   
161. //将字符串拷贝到新的位置   
162. char *strdup_(char *strSrc)  
163. {       
164.     if(strSrc!=NULL)       
165.     {       
166.         char *start=strSrc;       
167.         int len=0;       
168.         while(*strSrc++!='\0')       
169.             len++;       
170.             
171.         char *address=(char *)malloc(len+1);       
172.         assert(address != NULL);    
173.             
174.         while((*address++=*start++)!='\0');        
175.         return address-(len+1);        
176.     }       
177.     return NULL;       
178. }  

c标准库部分源代码

[cpp] view plaincopy

1. char * __cdecl strcat (char * dst,const char * src)    
2. {    
3.     char * cp = dst;    
4.         
5.     while( *cp )    
6.         cp++;                   /* find end of dst */    
7.         
8.     while( *cp++ = *src++ ) ;       /* Copy src to end of dst */    
9.         
10.     return( dst );                  /* return dst */    
11.         
12. }    
13.     
14. int __cdecl strcmp (const char * src,const char * dst)    
15. {    
16.     int ret = 0 ;    
17.         
18.     while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)    
19.         ++src, ++dst;    
20.         
21.     if ( ret < 0 )    
22.         ret = -1 ;    
23.     else if ( ret > 0 )    
24.         ret = 1 ;    
25.         
26.     return( ret );    
27. }    
28.     
29. size_t __cdecl strlen (const char * str)    
30. {    
31.     const char *eos = str;    
32.         
33.     while( *eos++ ) ;    
34.         
35.     return( (int)(eos - str - 1) );    
36. }    
37.     
38. char * __cdecl strncat (char * front,const char * back,size_t count)    
39. {    
40.     char *start = front;    
41.         
42.     while (*front++)    
43.         ;    
44.     front--;    
45.         
46.     while (count--)    
47.         if (!(*front++ = *back++))    
48.             return(start);    
49.             
50.         *front = '\0';    
51.         return(start);    
52. }    
53.     
54. int __cdecl strncmp (const char * first,const char * last,size_t count)    
55. {    
56.     if (!count)    
57.         return(0);    
58.         
59.     while (--count && *first && *first == *last)    
60.     {    
61.         first++;    
62.         last++;    
63.     }    
64.         
65.     return( *(unsigned char *)first - *(unsigned char *)last );    
66. }    
67.     
68. /* Copy SRC to DEST.  */    
69. char *  strcpy (char * dest,const char* src)     
70. {    
71.     reg_char c;    
72.     char *__unbounded s = (char *__unbounded) CHECK_BOUNDS_LOW (src);    
73.     const ptrdiff_t off = CHECK_BOUNDS_LOW (dest) - s - 1;    
74.     size_t n;    
75.         
76.     do    
77.     {    
78.         c = *s++;    
79.         s[off] = c;    
80.     }    
81.     while (c != '\0');    
82.         
83.     n = s - src;    
84.     (void) CHECK_BOUNDS_HIGH (src + n);    
85.     (void) CHECK_BOUNDS_HIGH (dest + n);    
86.         
87.     return dest;    
88. }    
89.     
90. char * __cdecl strncpy (char * dest,const char * source,size_t count)    
91. {    
92.     char *start = dest;    
93.         
94.     while (count && (*dest++ = *source++))    /* copy string */    
95.         count--;    
96.         
97.     if (count)                              /* pad out with zeroes */    
98.         while (--count)    
99.             *dest++ = '\0';    
100.             
101.         return(start);    
102. }