string函数功能实现

（1）strlen函数

函数原型：size_t strlen(const char *s);

功能：计算给定字符串的（unsigned int型）长度，不包括'\0'在内，如果给定的的字符串没赋初值，它会从字符串首地址一直计算，直到遇到'\0'停止。

代码实现：

 

1. #include <stdio.h>

2.  

3. int my_strlen(const char *s)

4. {

5. const char *p = s;

6.  

7. while(*p != '\0')

8. {

9. p++;

10. }

11. return p - s;

12. }

13.  

14. int main()

15. {

16. char a[20] = "Hello,World";

17. int len = my_strlen(a);

18.  

19. printf("%d\n",len);

20. return 0;

21. }

（2）strcmp函数

 

函数原型： int strcmp（const char *s1, const char *s2);

功能：比较两个字符串，设这两个字符串为str1，str2，若str1==str2，则返回零；若str1<str2，则返回负数；若str1>str2，则返回正数。

代码实现：

 

1. #include <stdio.h>

2.  

3. int my_strcmp(const char *s1, const char *s2)

4. {

5. int ret = 0;

6.  

7. if(NULL == s1 || NULL == s2 )

8. {

9. return;

10. }

11. while(*s1 && *s2 && (*s1 == *s2))

12. {

13. s1++;

14. s2++;

15. }

16. ret = *s1 - *s2;

17. if(ret > 0)

18. {

19. return 1;

20. }

21. if(ret == 0)

22. {

23. return 0;

24. }

25. if(ret < 0)

26. {

27. return -1;

28. }

29. }

30.  

31. int main()

32. {

33. char a[10] = "Hello";

34. char b[10] = "Wrold";

35. int date = 0;

36.  

37. date = my_strcmp(a,b);

38. printf("%d\n",date);

39. return 0;

40. }

（3）strcat函数

 

函数原型： char *strcat(char *dest, const char *src);

功能：把src所指字符串添加到dest结尾处(覆盖dest结尾处的'\0')，即字符串拼接。

代码实现：

 

1. #include <stdio.h>

2.  

3. char *my_strcat(char *dest, const char *src)

4. {

5. char *temp = dest;

6.  

7. if(NULL == src)

8. {

9. return dest;

10. }

11. while(*dest != '\0')

12. {

13. dest++;

14. }

15. while((*dest++ = *src++) != '\0')

16. {

17. ;

18. }

19. dest = '\0';

20. return temp;

21. }

22.  

23. int main()

24. {

25. char a[20] = {"Hello"};

26. char b[10] = {"World"};

27.  

28. my_strcat(a,b);

29. printf("%s\n",a);

30. return 0;

31. }

 

（4）strncat()函数

函数原型： char *strncat(char *dest, const char *src, size_t n);

功能：字符串拼接，同上！（前n个字符）。

代码实现:

 

1. #include <stdio.h>

2. #include <assert.h>

3.  

4. char *my_strncat(char *dest, const char *src,size_t n)

5. {

6. char *ret = dest;

7.  

8. assert(NULL != dest && NULL != src); //前置条件断言：代码执行之前必须具备的特性

9.  

10. while(*dest != '\0')

11. {

12. dest++;

13. }

14. while(n &&((*dest++ = *src++) != '\0'))

15. {

16. n--;

17. }

18. dest = '\0';

19. return ret;

20. }

21.  

22. int main()

23. {

24. char a[20] = {"Hello"};

25. char b[20] = {"World"};

26.  

27. my_strncat(a,b,4);

28. printf("%s\n",a);

29. return 0;

30. }

 

（5）strcpy函数

函数原型： char *strcpy(char *dest, const char *src);

功能：把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间

代码实现：

 

1. #include <stdio.h>

2. #include <assert.h>

3.  

4. char *my_strcpy(char *dest ,const char *src)

5. {

6. char *ret = dest;

7.  

8. assert(NULL != dest); //断言宏：前置条件断言：代码执行之前必须具备的特性，在<assert.h>头文件中

9. assert(NULL != src);

10. while((*dest++ = *src++) != '\0');

11. return ret;

12.  

13. }

14.  

15. int main()

16. {

17. char a[20] = {0};

18. char b[20] = {"Hello,World!"};

19.  

20. my_strcpy(a,b);

21. printf("%s\n",a);

22. return 0;

23. }

(6)strncpy函数

 

函数原型： char *strncpy(char *dest, const char *src, size_t n);

功能：字符串拷贝操作，同上（前 n 个字符）。

代码实现：

 

1. #include <stdio.h>

2. #include <assert.h>

3.  

4. char *my_strncpy(char *dest, const char *src, size_t n)

5. {

6. char *ret = dest;

7.  

8. assert(NULL != dest && NULL != src) ; //前置条件断言：代码执行之前必须具备的特性

9.  

10. while(n && ((*dest++ = *src++ ) != '\0'))

11. {

12. n--;

13. }

14. dest = '\0';

15. return ret;

16. }

17.  

18. int main()

19. {

20. char a[20] = {0};

21. char b[20] = {"Hello,World!"};

22.  

23. my_strncpy(a,b,8);

24. printf("%s\n",a);

25. return 0;

26. }

（7）strchr函数

 

函数原型：char *strchr (const char * s, int c);

功能：查找字符串s中首次出现字符c的位置，str 为目标字符串  c 为要查找的字符。

代码实现：

 

1. #include <stdio.h>

2.  

3. char *my_strchr(const char *s,int c)

4. {

5.  

6. if(NULL == s)

7. {

8. return NULL;

9. }

10. while('\0' != *s)

11. {

12. if(*s - c == 0)

13. {

14. return (char *)s;

15. }

16. s++;

17. }

18. return NULL;

19. }

20.  
21.  

22. int main()

23. {

24. char *a = "Hello,World!";

25. char *ret;

26.  

27. ret = my_strchr(a,'e');

28. printf("%s\n",ret);

29. return 0;

30. }

（8）strtok函数

 

函数原型： char *strtok(char *str, const char *delim);

功能：分解字符串为一组字符串。str为要分解的字符，delim为分隔符字符（如果传入字符串，则传入的字符串中每个字符均为分割符）。首次调用时，str指向要分解的字符串，之后再次调用要把str设成NULL。

代码实现：

1. #include <stdio.h>

2.  

3. char *my_strtok(char *str, const char *delim)

4. {

5. static char *move = NULL;

6. char *save_str;

7. const char *p = delim;

8. int i = 0, len;

9.  

10. if(NULL != str)

11. {

12. move = str;

13. }

14. if('\0'== move)

15. {

16. save_str = NULL;

17. }

18. else

19. {

20. save_str = move;

21. }

22.  

23. while('\0' != *p)

24. {

25. p++;

26. }

27. len = p - delim;

28.  

29. while('\0' != *move)

30. {

31. for(i = 0;i < len;i++)

32. {

33. if(delim[i] == *move)

34. {

35. *move = '\0';

36. move++;

37. return save_str;

38. }

39. }

40. move++;

41. }

42. return save_str;

43. }

44.  

45. int main()

46. {

47. char a[50] = {"ABCD,1234,!@#$,abcd"};

48.  

49. printf("%s\n",my_strtok(a,","));

50. return 0;

51. }

（9）memcpy函数

 

函数原型： void *memcpy(void *dest, const void *src, size_t n);

功能：从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中。

代码实现（1）：

 

1. #include <stdio.h>

2.  

3. void *my_memcpy(void *dest,const void *src,size_t n)

4. {

5. char *pd = (char *)dest;

6. char *ps = (char *)src;

7.  

8. while(n--)

9. {

10. *pd++ = *ps++;

11. }

12. return dest;

13. }

14.  

15. int main()

16. {

17. char a[20] = {0};

18. char b[20] = "Hello,World!";

19.  

20. my_memcpy(a,b,8);

21. printf("%s\n",a);

22. return 0;

23. }

代码实现（2）：

 

 

1. #include <stdio.h>

2.  

3. void *my_memcpy(void *dest, const void *src, size_t n)

4. {

5. int num_cpu = n / (sizeof(dest)); //按位宽拷贝

6. int num_char = n % (sizeof(dest)); //按字节拷贝

7. unsigned long *pd = (unsigned long *)dest;

8. const unsigned long *ps = (unsigned long *)src;

9.  

10. if((NULL == dest) || (NULL == src))

11. {

12. return NULL;

13. }

14. while(num_cpu--)

15. {

16. *pd++ = *ps++;

17. }

18. while(num_char--)

19. {

20. *((char *)pd++) = *((char *)ps++);

21. }

22. return dest;

23. }

24.  

25. int main()

26. {

27. char a[20] = {0};

28. char b[20] = "Hello,World!";

29.  

30. my_memcpy(a,b,8);

31. printf("%s\n",a);

32. return 0;

33. }

注：本系统为32位数;

 

(10)memmove函数

函数原型：void *memmove(void *dest, const void *src,size_t n);

功能：从src拷贝n个字节到dest，如果目标区域和源区域有重叠的话，memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中。但复制后src内容会被更改，但是当目标区域与源区域没有重叠则和memcpy函数功能相同。

代码实现：

 

1. #include <stdio.h>

2.  

3. void *my_memmove(void *dest, const void *src,size_t n)

4. {

5. char *pd,*ps;

6.  

7. if((NULL == dest) || (NULL == src))

8. {

9. return NULL;

10. }

11. if((char *)dest > (char *)src &&(char *)dest < (char *)src + n )

12. {

13. pd = (char *)dest + n - 1;

14. ps = (char *)src + n - 1;

15. while(n--)

16. {

17. *pd-- = *ps--;

18. }

19. }

20. else

21. {

22. pd = (char *)dest;

23. ps = (char *)src;

24. while(n--)

25. {

26. *pd++ = *ps++;

27. }

28. }

29. return dest;

30. }

31.  

32. int main()

33. {

34. char a[20] = {0};

35. char b[20] = {"Hello,World!"};

36.  

37. my_memmove(a,b,8);

38. printf("%s\n",a);

39. return 0;

40. }

注：相比上个memcpy函数，该函数考虑了内存重叠的情况，概括的讲，内存重叠分为两种情况；

 

（1）如果是前面的内存要复制到后面的内存，那么每次移动的时候应该倒序复制字节。

（2）如果是后面的内存复制到前面的内存，那么每次移动的时候应该正序复制字节。

（11）memset函数

函数原型： void *memset(void *s, int c, size_t n);

功能：作用是在一段内存块中填充某个给定的值，它是对较大的结构体或数组进行清零操作的一种常用方法

注：按字节填充

代码实现：

 

1. #include <stdio.h>

2.  

3. void *my_memset(void *s,int c,size_t n)

4. {

5. char *ps = (char *)s;

6.  

7. if((NULL == s) || c < 0)

8. {

9. return NULL;

10. }

11. while(n--)

12. {

13. *ps++ = c;

14. }

15. return s;

16. }

17.  

18. int main()

19. {

20. char a[10] = {1,2,3,4,5,6,7,8,9,10};

21. int i;

22.  

23. for(i = 0;i < 10;i++)

24. {

25. printf("a[%d]=%d ",i,a[i]);

26. }

27. printf("\n");

28. printf("=======================\n");

29. my_memset(a,0,2);

30. for(i = 0;i < 10;i++)

31. {

32. printf("a[%d]=%d ",i,a[i]);

33. }

34. printf("\n");

35. return 0;

36. }

（12）strstr函数

 

函数原型： char *strstr(const char *haystack, const char *needle);

功能：函数用于判断字符串needle是否是haystack的子串。如果是，则该函数返回needle在haystack中首次出现的地址；否则，返回NULL。

代码实现：

 

1. #include <stdio.h>

2.  

3. char *my_strstr(const char *haystack, const char *needle)

4. {

5. const char *ph;

6. const char *pn;

7. if(NULL == haystack || NULL == needle)

8. {

9. return NULL;

10. }

11. while('\0' != *haystack)

12. {

13. ph = haystack;

14. pn = needle;

15. do{

16. if('\0' == *pn)

17. {

18. return (char *)haystack;

19. }

20. }while(*ph++ == *pn++);

21. haystack++;

22. }

23. return NULL;

24. }

25.  

26. int main()

27. {

28. const char *a = "Hello,World!";

29. const char *b = "ll";

30. const char *ret = NULL;

31.  

32. ret = my_strstr(a,b);

33. printf("%s\n",ret);

34. return 0;

35. }