深入理解并模拟实现函数-阿里云开发者社区

前言：

我们前面已经学习了函数、指针等一系列知识，接下来，咱们一起来模拟实现strlen、qsort、strcpy、strcat、strcmp、strstr、memmove、memcpy、atoi，以及strncat、strncmp、strtok、strerror、memset、memcmp的使用。

一、使用并模拟实现qsort

qsort可以对函数进行排序，使函数从无序变成有序。以下是官网解释：

qsort函数也称之为快排。在确定好是降序还是升序后，经行快速排序，在所有排序中时间复杂度最低，效率更高。

下面是用代码演示一下：

1. #include <stdio.h>      /* printf */
2. #include <stdlib.h>     /* qsort */
3. 
4. int values[] = { 40, 10, 100, 90, 20, 25 };
5. 
6. int compare(const void* a, const void* b)
7. {
8. return (*(int*)a - *(int*)b);
9. }
10. 
11. int main()
12. {
13. int n;
14. qsort(values, 6, sizeof(int), compare);
15. for (n = 0; n < 6; n++)
16. printf("%d ", values[n]);
17. return 0;
18. }

运行结果如下：

相信大家对此函数有了初步了解，那下面进行模拟实现（冒泡实现）。

1. #include<stdio.h>
2. #include<assert.h>
3. int cmp(const void* p1,const void* p2)
4. {
5.  return ((*(int*)p1) - (*(int*)p2));
6. }
7. void sweap(void* p1, void* p2, int sz)
8. {
9.  for (int i = 0; i < sz; i++)
10.   {
11.     int cmp = *((char*)p1+i);
12.     *((char*)p1 + i) = *((char*)p2 + i);
13.     *((char*)p2 + i) = cmp;
14.   }
15. }
16. void bubble(int* arr, int n, int sz, int(*cmp)(void*, void*))//使用void*为了适应各种指针类型
17. {
18. assert(arr);
19.   for (int i = 0; i < n-1; i++)
20.   {
21.     for (int j = 0; j < n - 1 - i; j++)
22.     {
23.       if (cmp((char*)arr + j * sz, (char*)arr + (j + 1) * sz) > 0)
24.       {
25.         sweap((char*)arr + j * sz, (char*)arr + (j + 1) * sz,sz);//使用char*能够访问到每个比特位
26.       }
27.     }
28.   }
29. }
30. int main()
31. {
32.   int arr[10] = { 1,2,3,8,9,4,5,1,3,10 };
33.   bubble(arr, sizeof(arr)/sizeof(arr[0]),sizeof(int), cmp);
34.   for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
35.   {
36.     printf("%d", arr[i]);
37.   }
38.   return 0;
39. }

二、使用模拟实现strlen

strlen可以实现统计数组中元素个数（包括空格）。官网解释如下：

字符串以 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前⾯出现的字符个数（不包含 '\0' )。

参数指向的字符串必须要以 '\0' 结束。

注意函数的返回值为size_t，是⽆符号的（易错）

strlen的使⽤需要包含头⽂件

使用代码如下：

1. /* strlen example */
2. #include <stdio.h>
3. #include <string.h>
4. 
5. int main ()
6. {
7. char szInput[256];
8. printf ("Enter a sentence: ");
9. gets (szInput);
10. printf ("The sentence entered is %u characters long.\n",(unsigned)strlen(szInput));
11. return 0;
12. }

对其模拟如下：

1. #include<stdio.h>
2. //法一：使用计数器方式
3. my_strlen(char* arr)
4. {
5.  int count = 0;
6.  while (*arr != 0)
7.  {
8.    count++;
9.    arr++;
10.   }
11.   return count;
12. }
13. //法二：使用递归方式
14. int my_strlen(char* arr)
15. {
16.   if (*arr == '\0')
17.   {
18.     return 0;
19.   }
20.   else
21.     return 1 + my_strlen(arr + 1);
22. }
23. //法三：使用指针-指针方式
24. int my_strlen(char* arr)
25. {
26.   char* s = arr;
27.   while (*arr != '\0')
28.   {
29.     arr++;
30.   }
31.   return arr - s;
32. }
33. int main()
34. {
35.   char arr[] = "12345";
36.   int ret = my_strlen(arr);
37.   printf("%d", ret);
38.   return 0;
39. }

以上三种方式供大家学习。

三、使⽤和模拟实现strcpy 函数

strcpy可将一个字符串拷贝到一个数组中。官网解释如下：

源字符串必须以 '\0' 结束。

会将源字符串中的 '\0' 拷⻉到⽬标空间。

⽬标空间必须⾜够⼤，以确保能存放源字符串。

⽬标空间必须可修改。

代码实现如下：

1. /* strcpy example */
2. #include <stdio.h>
3. #include <string.h>
4. 
5. int main()
6. {
7.  char str1[] = "Sample string";
8.  char str2[40];
9.  char str3[40];
10.   strcpy(str2, str1);
11.   strcpy(str3, "copy successful");
12.   printf("str1: %s\nstr2: %s\nstr3: %s\n", str1, str2, str3);
13.   return 0;
14. }

模拟实现如下：

1. #include<stdio.h>
2. char* my_strcpy(char* dest, const char* src)
3. {
4.  char* str = dest;
5.  while (*dest++ = *src++)
6.  {
7.    ;
8.  }
9.  return str;
10. }
11. int main()
12. {
13.   char arr1[] = "123456";
14.   char arr2[] = "abcdef";
15.   my_strcpy(arr1, arr2);
16.   printf("%s", arr1);
17.   return 0;
18. }

四、使用并模拟实现strcat 函数

strcat函数是字符串追加函数，也就是在字符串后面追加另一个字符串。官网解释如下：

使用该函数代码如下：

1. #include <stdio.h>
2. #include <string.h>
3. 
4. int main()
5. {
6.  char str[80];
7.  strcpy(str, "these ");
8.  strcat(str, "strings ");
9.  strcat(str, "are ");
10.   strcat(str, "concatenated.");
11.   puts(str);
12.   return 0;
13. }

源字符串必须以 '\0' 结束。

⽬标字符串中也得有 \0 ，否则没办法知道追加从哪⾥开始。

⽬标空间必须有⾜够的⼤，能容纳下源字符串的内容。

⽬标空间必须可修改。

模拟实现如下：

1. #include<stdio.h>
2. char* my_strcat(char* destination, const char* source)
3. {
4.  char* ret = destination;
5.  while (*destination)
6.  {
7.    destination++;
8.  }
9.  while (*destination++ = *source++)
10.   {
11.     ;
12.   }
13.   return ret;
14. }
15. int main()
16. {
17.   char arr1[] = "hello";
18.   char arr2[] = " world";
19.   my_strcat(arr1,arr2);
20.   printf("%s", arr1);
21.   return 0;
22. }

五、使用并模拟实现strcmp函数

strcmp函数是C语言中字符串比较函数，用于比较两个字符串的大小。官网解释如下：

如果相等则，返回零，若str>str2，则大于零，反之小于零。

使用该函数如下：

1. #include <stdio.h>
2. #include <string.h>
3. 
4. int main()
5. {
6. char key[] = "apple";
7. char buffer[80];
8. do
9.     {
10. printf("Guess my favorite fruit? ");
11. fflush(stdout);
12. scanf("%79s", buffer);
13.     } while (strcmp(key, buffer) != 0);
14. puts("Correct answer!");
15. return 0;
16. }

模拟实现该函数如下：

1. #include<stdio.h>
2. #include<assert.h>
3. int my_strcmp(const char* str1, const char* str2)
4. {
5.  assert(str1 && str2);
6.  while (*str1++ == *str2++)
7.  {
8.    if (*str1 == *str2)
9.    {
10.       return 0;
11.     }
12.   }
13.   return *str1 - *str2;
14. }
15. int main()
16. {
17.   char arr1[] = "abcd";
18.   char arr2[] = "ace";
19.   int ret = my_strcmp(arr1, arr2);
20.   if (ret > 0)
21.   {
22.     printf("arr1>arr2\n");
23.   }
24.   else if (ret < 0)
25.   {
26.     printf("arr1<arr2\n");
27.   }
28.   else
29.   {
30.     printf("arr1=arr2\n");
31.   }
32.   return 0;
33. }

六、使用并模拟实现strstr函数

strstr函数是在字符串str1中查找是否含有字符串str2，如果存在，返回str2在str1中第一次出现的地址；否则返回NULL。官网解释如下：

对其使用代码如下：

1. #include <stdio.h>
2. #include <string.h>
3. 
4. int main()
5. {
6. char str[] = "This is a simple string";
7. char* pch;
8.     pch = strstr(str, "simple");
9. if (pch != NULL)
10. strncpy(pch, "sample", 6);
11. puts(str);
12. return 0;
13. }

Returns a pointer to the first occurrence of str2 in str1, or a null pointer if str2 is not part of str1. （函数返回字符串str2在字符串str1中第⼀次出现的位置）。

The matching process does not include the terminating null-characters, but it stops there.（字符串的⽐较匹配不包含 \0 字符，以 \0 作为结束标志）。

模拟实现该函数如下：

1. #include<stdio.h>
2. char* my_strstr(const char* str1, const char* str2)
3. {
4.  char* p = (char*)str1;
5.  if (!*str2)
6.  {
7.    return str1;
8.  }
9.  while (*p)
10.   {
11.     char* s1 = p;
12.     char* s2 = (char*)str2;
13.     while (*s1 && *s2 && !(*s1 - *s2))
14.     {
15.       s1++;
16.       s2++;
17.     }
18.     if (*s2)
19.     {
20.       return p;
21.     }
22.     p++;
23.   }
24.   return NULL;
25. }
26. int main()
27. {
28.   char arr1[] = "This is a simple string";
29.   char arr2[] = "simple";
30.   my_strstr(arr1, arr2);
31.   printf(arr2);
32.   return 0;
33. }

七、使用strtok函数

char * strtok ( char * str, const char * sep);

sep参数指向⼀个字符串，定义了⽤作分隔符的字符集合

第⼀个参数指定⼀个字符串，它包含了0个或者多个由sep字符串中⼀个或者多个分隔符分割的标记。

strtok函数找到str中的下⼀个标记，并将其⽤ \0 结尾，返回⼀个指向这个标记的指针。（注： strtok函数会改变被操作的字符串，所以在使⽤strtok函数切分的字符串⼀般都是临时拷⻉的内容并且可修改。）

strtok函数的第⼀个参数不为 NULL ，函数将找到str中第⼀个标记，strtok函数将保存它在字符串中的位置。

strtok函数的第⼀个参数为 NULL ，函数将在同⼀个字符串中被保存的位置开始，查找下⼀个标记。

如果字符串中不存在更多的标记，则返回 NULL 指针。

官网解释如下：

使用该函数：

1. #include <stdio.h>
2. #include <string.h>
3. 
4. int main()
5. {
6.  char str[] = "- This, a sample string.";
7.  char* pch;
8.  printf("Splitting string \"%s\" into tokens:\n", str);
9.  pch = strtok(str, " ,.-");
10.   while (pch != NULL)
11.   {
12.     printf("%s\n", pch);
13.     pch = strtok(NULL, " ,.-");
14.   }
15.   return 0;
16. }

八、使用strerror函数

strerror函数可以把参数部分错误码对应的错误信息的字符串地址返回来。在不同的系统和C语⾔标准库的实现中都规定了⼀些错误码，⼀般是放在 errno.h 这个头⽂件中说明的，C语⾔程序启动的时候就会使⽤⼀个全⾯的变量errno来记录程序的当前错误码，只不过程序启动的时候errno是0，表⽰没有错误，当我们在使⽤标准库中的函数的时候发⽣了某种错误，就会讲对应的错误码，存放在errno中，⽽⼀个错误码的数字是整数很难理解是什么意思，所以每⼀个错误码都是有对应的错误信息的。strerror函数就可以将错误对应的错误信息字符串的地址返回。

官网解释如下：

代码使用函数：

1. #include <stdio.h>
2. #include <string.h>
3. #include <errno.h>
4. 
5. int main()
6. {
7.  FILE* pFile;
8.  pFile = fopen("unexist.ent", "r");
9.  if (pFile == NULL)
10.     printf("Error opening file unexist.ent: %s\n", strerror(errno));
11.   return 0;
12. }

九、使用strncmp函数

strcmp函数与strncmp函数从函数名看来基本一样，确实，它们确实大体上相同，区别为：n确定了比较多少个元素，官网解释如下：

其返回值也是相同。对其使用如下：

1. #include <stdio.h>
2. #include <string.h>
3. 
4. int main()
5. {
6.  char str[][5] = { "R2D2" , "C3PO" , "R2A6" };
7.  int n;
8.  puts("Looking for R2 astromech droids...");
9.  for (n = 0; n < 3; n++)
10.     if (strncmp(str[n], "R2xx", 2) == 0)
11.     {
12.       printf("found %s\n", str[n]);
13.     }
14.   return 0;
15. }

十、使用strncat函数

strncat函数与strcat函数的区别也类似与上述函数，只不过区别是拼接字节的个数仅此而已。官网解释如下：

使用该函数如下：

1. #include <stdio.h>
2. #include <string.h>
3. 
4. int main()
5. {
6.  char str1[20];
7.  char str2[20];
8.  strcpy(str1, "To be ");
9.  strcpy(str2, "or not to be");
10.   strncat(str1, str2, 6);
11.   puts(str1);
12.   return 0;
13. }

十一、使用并模拟实现memcpy函数

memcpy函数是C语言中内存函数，其功能和strcpy函数类似，以下为官网解释：

函数memcpy从source的位置开始向后复制num个字节的数据到destination指向的内存位置。

这个函数在遇到 '\0' 的时候并不会停下来。

如果source和destination有任何的重叠，复制的结果都是未定义的。

对其使用结果如下：

1. #include <stdio.h>
2. #include <string.h>
3. 
4. struct {
5.  char name[40];
6.  int age;
7. } person, person_copy;
8. 
9. int main()
10. {
11.   char myname[] = "Pierre de Fermat";
12. 
13.   /* using memcpy to copy string: */
14.   memcpy(person.name, myname, strlen(myname) + 1);
15.   person.age = 46;
16. 
17.   /* using memcpy to copy structure: */
18.   memcpy(&person_copy, &person, sizeof(person));
19. 
20.   printf("person_copy: %s, %d \n", person_copy.name, person_copy.age);
21. 
22.   return 0;
23. }

对其模拟代码如下：

1. #include<stdio.h>
2. #include<assert.h>
3. void* my_memcpy(void* destination, const void* source, size_t num)
4. {
5.  assert(destination && source);
6.  void* p = destination;
7.  while (num--)
8.  {
9.    *(char*)destination = *(char*)source;
10.     destination = (char*)destination + 1;
11.     source = (char*)source + 1;
12.   }
13.   return (p);
14. }
15. int main()
16. {
17.   int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
18.   int arr2[20] = { 0 };
19.   my_memcpy(arr2, arr1,40);
20.   for (int i = 0; i < 10; i++)
21.   {
22.     printf("%d ", arr2[i]);
23.   }
24.   return 0;
25. }

十二、使用并模拟实现memmove函数

memmove函数也是内存函数，它的作用是可以实现对目标字符串的拷贝并放入指定位置。官网解释如下：

和memcpy的差别就是memmove函数处理的源内存块和⽬标内存块是可以重叠的。

如果源空间和⽬标空间出现重叠，就得使⽤memmove函数处理。

试用该函数如下：

1. #include <stdio.h>
2. #include <string.h>
3. 
4. int main()
5. {
6.  char str[] = "memmove can be very useful......";
7.  memmove(str + 20, str + 15, 11);
8.  puts(str);
9.  return 0;
10. }

模拟实现如下：

1. #include<stdio.h>
2. #include<assert.h>
3. void* my_memmove(void* dest, const void* sour, size_t num)
4. {
5.  void* p = dest;
6.  if (dest < sour)
7.  {
8.    while (num--)
9.    {
10.       *(char*)dest = *(char*)sour;
11.       dest = (char *)dest+1;
12.       sour = (char*)sour + 1;
13.     }
14.   }
15.   else
16.   {
17.     dest = (char*)dest + num - 1;
18.     sour = (char*)sour + num - 1;
19. 
20.     while (num--)
21.     {
22.       *(char*)dest = *(char*)sour;
23.       dest = (char*)dest - 1;
24.       sour = (char*)sour - 1;
25.     }
26.   }
27.   return p;
28. }
29. int main()
30. {
31.   char str[] = "memmove can be very useful......";
32.   my_memmove(str + 20, str + 15, 11);
33.   puts(str);
34.   return 0;
35. }

十三、使用memset函数

memset是⽤来设置内存的，将内存中的值以字节为单位设置成想要的内容。官网解释如下：

使用函数如下：

1. #include <stdio.h>
2. #include <string.h>
3. 
4. int main()
5. {
6.  char str[] = "almost every programmer should know memset!";
7.  memset(str, '-', 6);
8.  puts(str);
9.  return 0;
10. }

十四、使用 memcmp函数

该函数即为比较函数与上文strncmp函数类似。官网解释如下：

使用该函数如下：

1. #include <stdio.h>
2. #include <string.h>
3. 
4. int main()
5. {
6.  char buffer1[] = "DWgaOtP12df0";
7.  char buffer2[] = "DWGAOTP12DF0";
8. 
9.  int n;
10. 
11.   n = memcmp(buffer1, buffer2, sizeof(buffer1));
12. 
13.   if (n > 0)
14.   {
15.     printf("'%s' is greater than '%s'.\n", buffer1, buffer2);
16.   }
17.   else if (n < 0)
18.   {
19.     printf("'%s' is less than '%s'.\n", buffer1, buffer2);
20.   }
21.   else
22.   {
23.     printf("'%s' is the same as '%s'.\n", buffer1, buffer2);
24.   }
25.   return 0;
26. }

十五、使用并模拟实现atoi函数

它的功能：

解析将其内容解释为整数的 C 字符串，该整数作为类型的值返回。

该函数首先根据需要丢弃尽可能多的空格字符（如），直到找到第一个非空格字符。然后，从此字符开始，取一个可选的首字母加号或减号，后跟尽可能多的 10 进制数字，并将它们解释为数值。

字符串可以在构成整数的字符之后包含其他字符，这些字符将被忽略，并且对此函数的行为没有影响。

如果中的第一个非空格字符序列不是有效的整数，或者由于为空或仅包含空格字符而不存在此类序列，则不执行转换并返回零。

官网解释：

使用该函数如下：

1. #include <stdio.h>
2. #include <string.h>
3. int main()
4. {
5.  int i;
6.  char buffer[256];
7.  printf("Enter a number: ");
8.  fgets(buffer, 256, stdin);
9.  i = atoi(buffer);
10.   printf("The value entered is %d. Its double is %d.\n", i, i * 2);
11.   return 0;
12. }

模拟实现如下：

1. #include<stdio.h>
2. #include<assert.h>
3. #include<ctype.h>
4. #include<stdlib.h>
5. enum State
6. {
7.  INVAILD,
8.  VAILD
9. }a;
10. int my_atoi(const char* str)
11. {
12.   assert(str);
13.   if (*str == '\0')
14.   {
15.     return 0;
16.   }
17.   while (isspace(*str))
18.   {
19.     str++;
20.   }
21.   int flag = 1;
22.   if (*str == '+')
23.   {
24.     flag = 1;
25.     str++;
26.   }
27.   if (*str == '-')
28.   {
29.     flag = -1;
30.     str++;
31.   }
32.   long long ret = 0;
33.   while (*str != '\0')
34.   {
35.     if (isdigit(*str))
36.     {
37.       ret = ret * 10 + flag * (*str - '0');
38.       if (ret > INT_MAX)
39.       {
40.       return INT_MAX;
41.       }
42.       if (ret < INT_MIN)
43.       {
44.       return INT_MIN;
45.       }
46.     }
47.     else
48.     {
49.        (int)ret;
50.     }
51.     str++;
52.   }
53.   if (*str == '\0')
54.   {
55.      a =VAILD;
56.   }
57.   return (int)ret;
58. }
59. int main()
60. {
61.   char arr[20] = "-123456";
62.   int ret = my_atoi(arr);
63.   if (a == VAILD)
64.   {
65.     printf("合法转化:%d\n", ret);
66.   }
67.   else if(a == INVAILD)
68.   {
69.     printf("非法转化:%d\n", ret);
70.   }
71.   return 0;
72. }

完！

深入理解并模拟实现函数

前言：

一、使用并模拟实现qsort

二、使用模拟实现strlen

三、使⽤和模拟实现strcpy 函数

四、使用并模拟实现strcat 函数

五、使用并模拟实现strcmp函数

六、使用并模拟实现strstr函数

七、使用strtok函数

八、使用strerror函数

九、使用strncmp函数

十、使用strncat函数

十一、使用并模拟实现memcpy函数

十二、使用并模拟实现memmove函数

十三、使用memset函数

十四、使用 memcmp函数

十五、使用并模拟实现atoi函数

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

深入理解并模拟实现函数

前言：

一、使用并模拟实现qsort

二、使用模拟实现strlen

三、使⽤和模拟实现strcpy 函数

四、使用并模拟实现strcat 函数

五、使用并模拟实现strcmp函数

六、使用并模拟实现strstr函数

七、使用strtok函数

八、使用strerror函数

九、使用strncmp函数

十、使用strncat函数

十一、使用并模拟实现memcpy函数

十二、使用并模拟实现memmove函数

十三、使用memset函数

十四、使用 memcmp函数

十五、使用并模拟实现atoi函数

热门文章

最新文章

相关电子书