【C语言进阶】--- 字符串函数与内存函数

字字符串函数

1.strlen函数

size_t strlen(const char* str);
功能：盘算指针str指向的字符串的字符个数
字符串以’\0’作为结束标记，strlen函数返回的是字符串中’\0’前面出现的字符个数（不包括’\0’）
参数指向的字符串必须要以’\0’结束
注意函数的返回值是size_t
模仿实现

1. size_t m_strlen(const char* str)
2. {
3.         int count = 0;
4.         while (*str++)
5.         {
6.                 count++;
7.         }
8.         return count;
9. }
11. int main()
12. {
13.         char arr[] = "asdfgh";
14.         int ret = m_strlen(arr);
15.         printf("%d\n", ret);
17.         return 0;
18. }

复制代码

2.strcpy函数

char* strcpy(char* destination, const char* source);
功能：将指针source指向的字符串的内容拷贝到指针destination指向的字符串里
源字符串必须以’\0’结束
会将源字符串中的’\0’拷贝到目标空间
目标空间必须大，以确保能存放源字符串
目标空间必须是可修改的（好比：char * p = “xxxxxxxxx”;这里的字符串是常量，不能被修改）
模仿实现

1. char* m_strcpy(char* str1, const char* str2)
2. {
3.         char* tmp = str1;
4.         while (*str2)
5.         {
6.                 *str1++ = *str2++;
7.         }
8.         return tmp;
9. }
11. int main()
12. {
13.         char arr1[10] = "abcde";
14.         char arr2[] = "qwer";
15.         char* p = m_strcpy(arr1, arr2);
16.         printf("%s\n", p);
18.         return 0;
19. }

复制代码

3.strcat函数

char* strcat(char* destination,const* source);
功能：将指针source指向的字符串的内容拷贝到指针destination指向字符串的第一个出现字符’\0’的位置
源字符必须以’\0’结束
目标空间必须足够大，能容纳下源字符串的内容
目标空间必须可以修改
模仿实现

1. char* m_strcat(char* str1, const char* str2)
2. {
3.         char* tmp = str1;
4.         while (*str1)
5.         {
6.                 str1++;
7.         }
8.         while (*str2)
9.         {
10.                 *str1++ = *str2++;
11.         }
12.         return tmp;
13. }
15. int main()
16. {
17.         char arr1[10] = "abcde";
18.         char arr2[] = "qwer";
19.         char* p = m_strcat(arr1, arr2);
20.         printf("%s\n", p);
22.         return 0;
23. }

复制代码

4.strcmp函数

int strcmp(const char* str1, const char* str2);
功能：比较两个字符串的巨细
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串即是第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字
模仿实现

1. nt m_strcmp(const char* str1, const char* str2)
2. {
3.         while (*str1 == *str2)
4.         {
5.                 if (*str1 == '\0')
6.                         return 0;
7.                 str1++;
8.                 str2++;
9.         }
10.         return *str1 - *str2;
11. }
13. int main()
14. {
15.         char arr1[] = "abac";
16.         char arr2[] = "abad";
17.         int ret = m_strcmp(arr1, arr2);
18.         printf("%d\n", ret);
20.         return 0;
21. }

复制代码

5.strstr函数

char* strstr(const char* str1, const char* str2);
功能：返回 字符串2第一次出现在字符串1中第一个字符的位置，若找不到，返回null
模仿实现

1. char* m_strstr(const char* str1, const char* str2)
2. {
3.         char* cp = str1;
4.         char* s1 = cp;
5.         char* s2 = str2;
6.         while (*cp)
7.         {
8.                 s1 = cp;
9.                 s2 = str2;
10.                 while (*s1 && *s2 && *s1 == *s2)
11.                 {
12.                         s1++;
13.                         s2++;
14.                 }
15.                 if (*s2=='\0')
16.                         return cp;
17.                 cp++;
18.         }
19.         return NULL;
20. }
22. int main()
23. {
24.         char arr1[] = "abbbcdef";
25.         char arr2[] = "bbce";
26.         char* p = m_strstr(arr1, arr2);
27.         if (p == NULL)
28.                 printf("没找到");
29.         else
30.                 printf("找到了");
32.         return 0;
33. }

复制代码

6.strtok函数

char* strtok(char* str, const char* delimiters);
功能：在字符串1中寻找字符串2中的字符，若遇到，则替换成空字符并标记这个位置，最终返回字符串1的地址
此时打印该字符串只能打印到空字符的位置
若想打印后面的字符串，需在再次调用该函数，并且传的参数应为NULL和字符串2
应用

1. #include<string.h>
2. int main()
3. {
4.         char arr1[] = "192.192.55.0";
5.         char copy[30];
6.         strcpy(copy, arr1);
7.         char arr2[] = ".";
9.         char* ret = NULL;
10.         for (ret = strtok(copy, arr2); ret != NULL; ret = strtok(NULL, arr2))
11.         {
12.                 printf("%s ", ret);
13.         }
15.         return 0;
16. }

复制代码

7.strerror函数

char* sterror(int errnum);
功能：返回错误码所对应的错误信息（的地址）
库函数在执行中，发生了错位，会将一个错误码存放在errno这个变量中，errno是C语言提供的一个全局变量
好比：0 1 2 3 4 5…这些数在内存中对应差别的错误信息

1. #include<string.h>
2. int main()
3. {
4.         FILE* pf = fopen("test.txt", "r");
5.         if (pf == NULL)
6.         {
7.                 printf("%s\n", strerror(errno));
8.         }
9.         else
10.         {
11.                 printf("成功打开");
12.         }
13.         //printf("%s\n", strerror(0));
14.         //printf("%s\n", strerror(1));
15.         //printf("%s\n", strerror(2));
16.         return 0;
17. }

复制代码

关于内存的函数

1.memcpy函数

void* memcpy(void* destination, const void* scoure, size_t num);
功能：从source的位置开始赋值num个字节的数据到destination的内存位置，返回目的空间的起始位置
处理不相关，不重叠的内存
任何范例都可以实现该功能
模仿实现

1. void* m_memcpy(void* dest, const void* scr, size_t num)
2. {
3.         void* tmp = dest;
4.         while (num--)
5.         {
6.                 *(char*)dest = *(char*)scr;
7.                 dest = (char*)dest + 1;
8.                 scr = (char*)scr + 1;
9.         }
10.         return tmp;
12. }
13. int main()
14. {
15.         int arr1[] = { 1,2,3,4,5,6 };
16.         int arr2[] = { 7,8,9,10 };
17. 这里不能实现arr1+2向arr1中的内存替换
18.         int* p = m_memcpy(arr1, arr2, 8);
19.         for (int i = 0; i < sizeof(arr1) / sizeof(arr1[0]); i++)
20.         {
21.                 printf("%d\n", arr1[i]);
22.         }
24.         return 0;
25. }

复制代码

2.memmove函数

void* memcpy(void* destination, const void* scoure, size_t num);
memcpy函数的升级版，可以实现重叠内存的拷贝
模仿实现

1. void* m_memmove(void* dest, const void* scr, size_t num)
2. {
3.         void* tmp = dest;
4.         if (dest < scr)
5.         {
6.                 //前
7.                 while (num--)
8.                 {
9.                         *((char*)dest) = *((char*)scr);
10.                         dest = (char*)dest + 1;
11.                         scr = (char*)scr + 1;
12.                 }
13.                
14.         }
15.         if (dest > scr)
16.         {
17.                 //后
18.                 while (num--)
19.                 {
20.                         *((char*)dest + num) = *((char*)scr + num);
21.                 }
23.         }
24.         return tmp;
25.        
26. }
28. int main()
29. {
30.         int arr1[] = { 1,2,3,4,5,6 };
31.         int* p = m_memmove(arr1+2, arr1, 8);
32.         for (int i = 0; i < sizeof(arr1) / sizeof(arr1[0]); i++)
33.         {
34.                 printf("%d\n", arr1[i]);
35.         }
37.         return 0;
38. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。