一些常用字符串操作函数的内部实现

常用的字符串库函数的内部实现，截自linux内核中的lib/string.c文件，绝对标准的程序，供大家参考。

    

memset:

1. /*
   
2.  * memset - Fill a region of memory with the given value
   
3.  * @s: Pointer to the start of the area.
   
4.  * @c: The byte to fill the area with
   
5.  * @count: The size of the area.
   
6.  */
   
7. void *memset(void *s, int c, size_t count)
   
8. {
   
9.     char *xs = s;
   
10. 
    
11.     while (count--)
    
12.         *xs++ = c;
    
13.     return s;
    
14. }

memcpy:

1. /*
2. * memcpy - Copy one area of memory to another
3. * @dest: Where to copy to
4. * @src: Where to copy from
5. * @count: The size of the area.
6. */
7. void *memcpy(void *dest, const void *src, size_t count)
8. {
9. char *tmp = dest;
10. const char *s = src;
12. while (count--)
13. *tmp++ = *s++;
14. return dest;
15. }

memmove:

1. /*
   
2.  * memmove - Copy one area of memory to another
   
3.  * @dest: Where to copy to
   
4.  * @src: Where to copy from
   
5.  * @count: The size of the area.
   
6.  * Unlike memcpy(), memmove() copes with overlapping areas.
   
7.  */
   
8. void *memmove(void *dest, const void *src, size_t count)
   
9. {
   
10.     char *tmp;
    
11.     const char *s;
    
12. 
    
13.     if (dest <= src) {
    
14.         tmp = dest;
    
15.         s = src;
    
16.         while (count--)
    
17.             *tmp++ = *s++;
    
18.     } else {
    
19.         tmp = dest;
    
20.         tmp += count;
    
21.         s = src;
    
22.         s += count;
    
23.         while (count--)
    
24.             *--tmp = *--s;
    
25.     }
    
26.     return dest;
    
27. }

memcmp:

1. /*
   
2.  * memcmp - Compare two areas of memory
   
3.  * @cs: One area of memory
   
4.  * @ct: Another area of memory
   
5.  * @count: The size of the area.
   
6.  */
   
7. int memcmp(const void *cs, const void *ct, size_t count)
   
8. {
   
9.     const unsigned char *su1, *su2;
   
10.     int res = 0;
    
11. 
    
12.     for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
    
13.         if ((res = *su1 - *su2) != 0)
    
14.             break;
    
15.     return res;
    
16. }

strcpy:

1. /*
   
2.  * strcpy - Copy a %NUL terminated string
   
3.  * @dest: Where to copy the string to
   
4.  * @src: Where to copy the string from
   
5.  */
   
6. char *strcpy(char *dest, const char *src)
   
7. {
   
8.     char *tmp = dest;
   
9. 
   
10.     while ((*dest++ = *src++) != '\0');
    
11. 
    
12.     return tmp;
    
13. }

strncpy:

1. /*
   
2.  * strncpy - Copy a length-limited, %NUL-terminated string
   
3.  * @dest: Where to copy the string to
   
4.  * @src: Where to copy the string from
   
5.  * @count: The maximum number of bytes to copy
   
6.  *
   
7.  * The result is not %NUL-terminated if the source exceeds
   
8.  * @count bytes.
   
9.  *
   
10.  * In the case where the length of @src is less than that of
    
11.  * count, the remainder of @dest will be padded with %NUL.
    
12.  */
    
13. char *strncpy(char *dest, const char *src, size_t count)
    
14. {
    
15.     char *tmp = dest;
    
16. 
    
17.     while (count) {
    
18.         if ((*tmp = *src) != 0)
    
19.             src++;
    
20.         tmp++;
    
21.         count--;
    
22.     }
    
23. 
    
24.     return dest;
    
25. }

strcat:

1. /*
   
2.  * strcat - Append one %NUL-terminated string to another
   
3.  * @dest: The string to be appended to
   
4.  * @src: The string to append to it
   
5.  */
   
6. char *strcat(char *dest, const char *src)
   
7. {
   
8.     char *tmp = dest;
   
9. 
   
10.     while (*dest)
    
11.         dest++;
    
12.     while ((*dest++ = *src++) != '\0');
    
13. 
    
14.     return tmp;
    
15. }

strncat:

1. /*
   
2.  * strncat - Append a length-limited, %NUL-terminated string to another
   
3.  * @dest: The string to be appended to
   
4.  * @src: The string to append to it
   
5.  * @count: The maximum numbers of bytes to copy
   
6.  *
   
7.  * Note that in contrast to strncpy(), strncat() ensures the result is
   
8.  * terminated.
   
9.  */
   
10. char *strncat(char *dest, const char *src, size_t count)
    
11. {
    
12.     char *tmp = dest;
    
13. 
    
14.     if (count) {
    
15.         while (*dest)
    
16.             dest++;
    
17.         while ((*dest++ = *src++) != 0) {
    
18.             if (--count == 0) {
    
19.                 *dest = '\0';
    
20.                 break;
    
21.             }
    
22.         }
    
23.     }
    
24. 
    
25.     return tmp;
    
26. }

strcmp:

1. /*
   
2.  * strcmp - Compare two strings
   
3.  * @cs: One string
   
4.  * @ct: Another string
   
5.  */
   
6. int strcmp(const char *cs, const char *ct)
   
7. {
   
8.     unsigned char c1, c2;
   
9. 
   
10.     while (1) {
    
11.         c1 = *cs++;
    
12.         c2 = *ct++;
    
13.         if (c1 != c2)
    
14.             return c1 < c2 ? -1 : 1;
    
15.         if (!c1)
    
16.             break;
    
17.     }
    
18. 
    
19.     return 0;
    
20. }

strncmp:

1. /*
   
2.  * strncmp - Compare two length-limited strings
   
3.  * @cs: One string
   
4.  * @ct: Another string
   
5.  * @count: The maximum number of bytes to compare
   
6.  */
   
7. int strncmp(const char *cs, const char *ct, size_t count)
   
8. {
   
9.     unsigned char c1, c2;
   
10. 
    
11.     while (count) {
    
12.         c1 = *cs++;
    
13.         c2 = *ct++;
    
14.         if (c1 != c2)
    
15.             return c1 < c2 ? -1 : 1;
    
16.         if (!c1)
    
17.             break;
    
18.         count--;
    
19.     }
    
20. 
    
21.     return 0;
    
22. }

strchr:

1. /*
   
2.  * strchr - Find the first occurrence of a character in a string
   
3.  * @s: The string to be searched
   
4.  * @c: The character to search for
   
5.  */
   
6. char *strchr(const char *s, int c)
   
7. {
   
8.     for (; *s != (char)c; ++s)
   
9.         if (*s == '\0')
   
10.             return NULL;
    
11. 
    
12.     return (char *)s;
    
13. }

strlen:

1. /*
   
2.  * strlen - Find the length of a string
   
3.  * @s: The string to be sized
   
4.  */
   
5. size_t strlen(const char *s)
   
6. {
   
7.     const char *sc;
   
8. 
   
9.     for (sc = s; *sc != '\0'; ++sc);
   
10. 
    
11.     return sc - s;
    
12. }

strnlen:

1. /*
   
2.  * strnlen - Find the length of a length-limited string
   
3.  * @s: The string to be sized
   
4.  * @count: The maximum number of bytes to search
   
5.  */
   
6. size_t strnlen(const char *s, size_t count)
   
7. {
   
8.     const char *sc;
   
9. 
   
10.     for (sc = s; count-- && *sc != '\0'; ++sc);
    
11. 
    
12.     return sc - s;
    
13. }

strsep:

1. /*
   
2.  * strsep - Split a string into tokens
   
3.  * @s: The string to be searched
   
4.  * @ct: The characters to search for
   
5.  *
   
6.  * strsep() updates @s to point after the token, ready for the next call.
   
7.  */
   
8. char *strsep(char **s, const char *ct)
   
9. {
   
10.     char *sbegin = *s;
    
11.     char *end;
    
12. 
    
13.     if (sbegin == NULL)
    
14.         return NULL;
    
15. 
    
16.     end = strpbrk(sbegin, ct);
    
17.     if (end)
    
18.         *end++ = '\0';
    
19.     *s = end;
    
20. 
    
21.     return sbegin;
    
22. }

strstr:

1. /*
   
2.  * strstr - Find the first substring in a %NUL terminated string
   
3.  * @s1: The string to be searched
   
4.  * @s2: The string to search for
   
5.  */
   
6. char *strstr(const char *s1, const char *s2)
   
7. {
   
8.     int l1, l2;
   
9. 
   
10.     l2 = strlen(s2);
    
11.     if (!l2)
    
12.         return (char *)s1;
    
13.     l1 = strlen(s1);
    
14.     while (l1 >= l2) {
    
15.         l1--;
    
16.         if (!memcmp(s1, s2, l2))
    
17.             return (char *)s1;
    
18.         s1++;
    
19.     }
    
20. 
    
21.     return NULL;
    
22. }

另外加上itoa(),atoi()，atof()实现（非内部实现）

1、itoa函数实现

[cpp]  view plain copy

1. #include <stdio.h>  
2.   
3. void itoa(int i, char *string)  
4. {  
5.         int power=0,j=0;  
6.   
7.         j=i;  
8.         for( power=1;j>10;j/=10)  
9.                 power*=10;  
10.   
11.         for(;power>0;power/=10)  
12.         {  
13.                 *string++='0'+i/power;  
14.                 i%=power;  
15.         }  
16.         *string='\0';  
17.         printf("%s\n",string);  
18. }  
19. void main()  
20. {  
21.         char string[20];  
22.         itoa(12345, string);  
23.         printf("%s\n",string);  
24. }  

其中power相当于类似于1234，其power=1000;134,其power=100

*string++='0'+i/power;//获得取得字符的asicii码

i/power取得字符，例如1234/1000=1;234/100=2

2、atoi实现

[cpp]  view plain copy

1. int atoi(char *str)  
2. {  
3.         if(!str)  
4.                 return -1;  
5.         bool bMinus=false;  
6.         int result=0;  
7.   
8.         if(('0'>*str || *str>'9')&&(*str=='+'||*str=='-'))  
9.         {  
10.                if(*str=='-')  
11.                 bMinus=true;  
12.                *str++;  
13.         }  
14.         while( *str != '\0')  
15.         {  
16.                 if('0'> *str || *str>'9')  
17.                         break;  
18.                 else  
19.                         result = result*10+(*str++ - '0');  
20.         }  
21.   
22.         if (*str != '\0')//no-normal end  
23.                 return -2;  
24.   
25.         return bMinus?-result:result;  
26. }  

重写的atoi函数，没有考虑溢出的情况。

 if(('0'>*str || *str>'9')&&(*str=='+'||*str=='-'))//判读第一个字符是否为数字的正负号

if (*str != '\0')//no-normal end，当上文的while循环不正常退出，应视为字符串不合法，例如“+1234abc”

测试：

[cpp]  view plain copy

1. char *c1 = "12345";  
2.         char *c2 = "-12345";  
3.         char *c3 = "bat-123";  
4.         char *c4 = "+123abc";  
5.   
6.   
7.         printf("c1=%d\n",atoi(c1));  
8.         printf("c2=%d\n",atoi(c2));  
9.         printf("c3=%d\n",atoi(c3));  
10.         printf("c4=%d\n",atoi(c4));  

输出结果为：

c1=12345
c2=-12345
c3=-2
c4=-2

3.atof()

#include<stdio.h>
#include<string.h>
#define SIZE 50
double atof(char *s);
void main()
{
 char s[SIZE];
 printf("Input a string:\n");
 gets(s);
 atof(s);
}
double atof(char *s)
{
 int i,j,k=0;
 float total,head = 0.0,tail = 0.0;
 for(i = 0;i<strlen(s);i++)
 {
  k++;
  if(*(s+i)=='.')
   break;
 } 
 for(j=0;j<k-1;j++)
 {
  head = head*10 + *(s+j)-'0';
 }
 for(i=strlen(s)-1;i>=k;i--)
 {
  tail = tail/10.0 + (*(s+i)-'0')/10.0;
 }
 total = head + tail;
 printf("S after atof:%f",total);
}