🎖️1.函数介绍

📬1.8. strstr

🚩（1）在字符串str1中找字符串str2第一次出现的位置，如果找不到则返回一个空指针（NULL）

可以参考一下 cplusplus 中的资料👇

🔴（1）请看示例代码👇

#include<stdio.h>
#include<string.h>

int main()
{
char arr1[] = "abcdbcdef";
char arr2[] = "bcd";
char* p = strstr(arr1, arr2);
if (p == NULL)
{
printf("找不到\n");
}
else
{
printf("%s\n", p);
}

return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

🔴（2）模拟实现 strstr函数👇

#include<stdio.h>
#include<string.h>

char* my_strstr(const char* str1, const char* str2)
{
char* s1 = NULL;
char* s2 = NULL;
char* cp = (char*)str1;

while (*cp)
{
s1 = cp;
s2 = (char*)str2;
while (*s1 && *s2 && *s1 == *s2)
{
s1++;
s2++;
}
if (*s2 == '\0')
{
return cp;   
}
cp++;
}
return NULL;
}

int main()
{
char arr1[] = "abcdbcdef";
char arr2[] = "bcd";
char* p = my_strstr(arr1, arr2);
if (p == NULL)
{
printf("找不到\n");
}
else
{
printf("%s\n", p);
}

return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

📬1.9. strtok

🔴函数原型👇
char* strtok(char* str, const char* sep);

🚩（1）sep参数是个字符串，定义了用作分割符的字符集合
🚩（2） 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分割符分割的标记
🚩（3）strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针（strtok函数会改变被操作的字符串，所以在使用strtok函数切分字符串一般都是临时拷贝的内容并且可修改）
🚩（4）strtok函数的第一个参数不为NULL，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置
🚩（5）strtok函数的第一个参数为NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记
🚩（6）如果字符串中不存在更多的标记，则返回 NULL指针

可以参考一下 cplusplus 中的资料👇

🔴（1）请看示例代码👇

//"shujujiegou@yeah.net"
//@. - 分割符

#include<stdio.h>
#include<string.h>

int main()
{
char arr[] = "shujujiegou@yeah.net";
char buf[30] = {0};
strcpy(buf, arr);

const char* p = "@.";
char* str = strtok(buf, p);
printf("%s\n", str);

str = strtok(NULL, p);
printf("%s\n", str);

str = strtok(NULL, p);
printf("%s\n", str);

return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

这个代码看起来十分的别扭，非常死板，如果是分三个串就要写三份代码，要是四个串就要写四份代码，如果要分一百个串呢，难不成要写一百份代码吗？

所以我们可以换一种巧妙的方式去写👇

#include<stdio.h>
#include<string.h>

int main()
{
char arr[] = "192.163.3.122";
char buf[30] = { 0 };
strcpy(buf, arr);

const char* p = ".";
char* str = NULL;
for (str = strtok(buf, p); str != NULL;str=strtok(NULL,p))
{
printf("%s\n", str);
}

return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

📬1.10. strerror

🔴函数原型👇
char* strerror(int errnum);
🔴返回错误码所对应的错误信息

可以参考一下 cplusplus 中的资料👇

🔴（1）请看示例代码👇

int main()
{
char* p = strerror(0);
printf("%s\n", p);

p = strerror(1);
printf("%s\n", p);

p = strerror(2);
printf("%s\n", p);

p = strerror(3);
printf("%s\n", p);

return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

🚩 C语言的库函数在调用失败的时候，会将一个错误码存放在一个叫：errno的变量中，当我们想知道调用库函数的时候发生了错误信息，就可以将：errno中的错误码翻译成错误信息

🌰再举个栗子👇

请看代码和注释👇

int main()
{
//打开文件
//打开文件的时候，如果文件的打开方式是"r"
//文件存在则打开成功，文件不存在则打开失败
//打开文件失败的话，会返回NULL
fopen("test.txt", "r");//"r"已读方式打开
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{
printf("打开文件失败，原因是：%s\n", strerror(errno));
}
//读写文件
//...
//关闭文件
fclose(pf);
pf - NULL;

return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

更高级一点的，如果想直接打印出错误信息，可以使用 perror👇

int main()
{
fopen("test.txt", "r");//"r"已读方式打开
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{
perror("打开文件失败");
return 1;
}
fclose(pf);
pf - NULL;

return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

📬1.11. memcpy

🔴拷贝数据
🔴上面的 strcpy函数是用来拷贝字符串的

参考一下 cplusplus 中的资料👇

🚨注意：这里 size_t num参数的单位是字节

🔴（1）请看示例代码与注释👇

void test1()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[8] = { 0 };
//把arr1中的前5个数据拷贝到arr2中
memcpy(arr2, arr1, 20);
}
1
2
3
4
5
6
7

🔴（2）请看示例代码与注释👇

void test2()
{
float arr1[] = { 1.0f,2.0f,3.0f,4.0f,5.0f };
float arr2[8] = { 0 };
//把arr1中的前3个数据拷贝到arr2中
memcpy(arr2, arr1, 12);
}
1
2
3
4
5
6
7

🔴（3）模拟实现一下 memcpy函数👇

//memcpy函数返回的是目标空间的起始地址
void* my_memcpy(void* dest, const void* src, size_t num)
{
void* ret = dest;
assert(dest && src);
while (num--)//4 3 2 1
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;
}

void test3()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[8] = { 0 };
//把arr1中的前5个数据拷贝到arr2中
my_memcpy(arr2, arr1, 20);
}

int main()
{
test3();
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

🔴（4）请看示例代码与注释👇
把前五个数据放在3 4 5 6 7的位置上

void* my_memcpy(void* dest, const void* src, size_t num)
{
void* ret = dest;
assert(dest && src);
while (num--)//4 3 2 1
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;
}

void test4()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
//把前五个数据放在3 4 5 6 7的位置上
my_memcpy(arr1+2, arr1, 20);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
}

int main()
{
test4();
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

🚨结果为什么不是我们期望的结果呢？怎么出问题了呢？

这里把1和2赋给3和4之后，3和4的位置的值已经被改变了，分别变成了1和2，那么再3和4赋给5和6位置的时候，赋的就是1和2，所以才会这样

所以我们发现：在内存重叠的时候，使用 memcpy可能出现意想不到的效果
建议：在内存重叠的情况，使用 memmove函数

📬1.12. memmove

先来参考一下 cplusplus 中的资料👇

🔴请看示例代码👇

void test4()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
//把前五个数据放在3 4 5 6 7的位置上
memmove(arr1 + 2, arr1, 20);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
}

int main()
{
test4();

return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

这次就成功完成了

🚩memcpy拷贝不重叠的内存
🚩重叠的就交给 memmore
🚩memmore > memcpy

📬1.13. memcmp

🔴内存比较函数（以字节为单位）

先来参考一下 cplusplus 中的资料👇

🔴请看示例代码👇

void test5()
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 1,2,3,4,6 };
int ret = memcmp(arr1, arr2, 16);
printf("%d\n", ret);
}

int main()
{
test5();

return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

void test5()
{
int arr1[] = { 1,2,3,4,5 };//01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00
int arr2[] = { 1,2,3,4,6 };//01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 06 00 00 00
int ret = memcmp(arr1, arr2, 17);
printf("%d\n", ret);
}

int main()
{
test5();

return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

📬1.14. memset

🔴内存设置函数（以字节为单位设置）

先来参考一下 cplusplus 中的资料👇

🔴请看示例代码👇

void test6()
{
char arr[] = "hello world";
memset(arr, 'x', 5);
printf("%s\n", arr);
}

int main()
{
test6();

return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

总结🥰
以上就是 字符函数和字符串函数【下篇】 的内容啦🥳🥳🥳🥳
本文章所在【C语言知识篇】专栏，感兴趣的烙铁可以订阅本专栏哦🥳🥳🥳
希望我们可以做一个用心的人💕💕💕
小的会继续学习，继续努力带来更好的作品😊😊😊
创作写文不易，还多请各位大佬uu们多多支持哦🥰🥰🥰