自定义实现字符串处理函数 strlen strcmp strcpy strncpy strcat strncat strchr strstr

1. 1. /****************************************************************************** 
   2.  *  author : kangquan@scut2008 
   3.  * 
   4.  *  blog : http://blog.csdn.net/kangquan2008 
   5.  * 
   6.  *  discription: 自定义实现字符串处理函数  
   7.  *  size_t strlen (const char * str); 
   8.  *  int strcmp (const char * src,const char * dst); 
   9.  *  char * strcat (char * dst, const char * src); 
   10.  *  char * strcpy(char * dst, const char * src); 
   11.  *  char * strncat (char * front,const char * back, size_t count); 
   12.  *  char * strncpy (char * dest, const char * source, size_t count); 
   13.  *  char * strchr (const char * string,int ch); 
   14.  *  char * strstr (const char * str1, const char * str2); 
   15.  * 
   16.  *****************************************************************************/  
   17. #include <stdio.h>  
   18. #include <stdlib.h>  
   19.   
   20.   
   21. size_t strlen (const char * str)  
   22. {  
   23.     const char * eos = str;  
   24.       
   25.     while( *eos++ );   
   26.     // *eos == '\0' 时，还加1，因为strlen是不包含'\0'的，  
   27.     // 所以下面-1.  
   28.       
   29.     return (eos - str - 1);// 不包含 '\0'  
   30. }  
   31.   
   32. // ugly implement   
   33. // 这个实现不是很好，首先没考虑const,然后返回值为有符号整数  
   34. int my_strlen ( char * str )  
   35. {  
   36.     int len = 0;  
   37.   
   38.     while( *str++ )  
   39.         len++;  
   40.   
   41.     return len;  
   42. }  
   43.   
   44. int strcmp (const char * src,const char * dst)  
   45. {  
   46.     int ret;  
   47.   
   48.     // 转为unsigned char，好处是？  
   49.     // 另外只判断 *dst != 0,因为此时已经有*src == *dst  
   50.     while( !(ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst )  
   51.         src++,dst++;  
   52.   
   53.     if(ret < 0)  
   54.         ret = -1;  
   55.     else if(ret > 0)  
   56.         ret = 1;  
   57.   
   58.     return ret;  
   59. }  
   60.   
   61. // ugly implement  
   62. // 这个实现并不好，因为没有考虑strcat嵌套使用的情况，好的实现见strcat  
   63. char * my_strcat (char * dst, const char * src)  
   64. {  
   65.     while( *dst )  
   66.         dst++; // 移到末尾  
   67.   
   68.     while( *dst++ = *src++);  
   69.   
   70.     *dst = '\0'; // 记得是*dst = '\0';而不是dst = '\0'  
   71.   
   72.     return dst;  
   73. }  
   74.   
   75. char * strcat (char * dst, const char * src)  
   76. {  
   77.     char * tmp = dst;   // 设置临时变量，  
   78.   
   79.     while( *dst )  
   80.         dst++; // 移到末尾  
   81.   
   82.     while( *dst++ = *src++);  
   83.   
   84.     *dst = '\0';  
   85.   
   86.     return tmp;  
   87. }  
   88.   
   89. char * strcpy(char * dst, const char * src)  
   90. {  
   91.     char * tmp = dst;  
   92.   
   93.     while( *dst++ = *src++ )  
   94.         ;  
   95.   
   96.     return tmp;  
   97. }  
   98.   
   99. char * strncat (char * dst,const char * src, size_t count)  
   100. {  
   101.     char * tmp = dst;  
   102.   
   103.     while( *dst )  
   104.         dst ++;  
   105.       
   106.     while( count-- ) // 先返回，后自增.count到1,则count个  
   107.         if( !( *dst++ = *src++ ) )   
   108.             return tmp;  // 已经发现'\0',直接返回，不要再加'\0'  
   109.       
   110.     *dst = '\0';  
   111.   
   112.     return tmp;  
   113. }  
   114.   
   115. char * strncpy(char * dst, const char * src, size_t count)  
   116. {  
   117.     char * tmp = dst;  
   118.   
   119.     while( count && (*dst++ = *src++) )  
   120.         count --;  
   121.   
   122.     if( !count )      // 复制了count个，加上'\0'  
   123.         *dst = '\0';  
   124.     else{  
   125.         while( --count ) // 在遇到'\0'且未复制够count个字符，补上'\0'  
   126.             *dst++ = '\0';  
   127.     }  
   128.   
   129.     return tmp;  
   130. }  
   131.    
   132. // '\0'也可以找  
   133. char * strchr (const char * string,int ch)  
   134. {  
   135. //  while( *string && *string++ != (char)ch ) // == 时还自增，这是不对的.  
   136. //      ;  
   137.   
   138.     while (*string && *string != (char)ch)  
   139.         string++;  
   140.   
   141.     if(*string == (char)ch)  
   142.         return (char *)string;  
   143.     return NULL;  
   144. }  
   145.   
   146.   
   147. char * strstr (const char * str1, const char * str2)  
   148. {  
   149.     char * index = (char *)str1;  
   150.     char *s1,*s2;  
   151.   
   152.     if( !*str2)  
   153.         return (char *)str1; // 要查找的为空，直接返回.  
   154.   
   155.     while( *index )  
   156.     {  
   157.         s1 = index;  
   158.         s2 = (char *)str2;  
   159.   
   160.         while( *s1 && *s2 && \  
   161.                 !(*(unsigned char *)s1-*(unsigned char *)s2))  
   162.             s1++,s2++;  
   163.   
   164.         if( !*s2 )  
   165.             return index;  
   166.           
   167.         index++;  
   168.     }  
   169.   
   170.     return NULL;  
   171.       
   172. }  
   173.   
   174. int main()  
   175. {  
   176.     char dst[] = "I come from ";  
   177.     char dst2[] = "I come from ";  
   178.     char src[] = "scut";  
   179.     char * tmp = NULL;  
   180.     char ch = 'c';  
   181.     char str[] = "from";  
   182.   
   183.     printf("my_strlen: %d\n",my_strlen(dst));  
   184.     printf("strlen: %d\n",strlen(dst));  
   185.     my_strcat(dst,src);  
   186.     printf("my_strcat: %s\n",dst);  
   187.     printf("strcat: %s\n",strcat(dst,src));  
   188.     printf("strncat: %s\n",strncat(dst,src,3));  
   189.     printf("strcpy: %s\n",strcpy(dst,src));  
   190.     printf("strncpy: %s\n",strncpy(dst,src,3));  
   191.     printf("strchr: %s\n",strchr(dst,ch) ? strchr(dst,ch):"NULL" );  
   192.     printf("strstr: %s\n",strstr(dst2,str)? strstr(dst2,str):"NULL" );  
   193.   
   194.     return 0;  
   195. }