进阶C语言——字符函数和字符串函数【详解】（二）

「爱情、让人受尽委屈。」 2023-10-11 21:21 9阅读 0赞

#### 文章目录 ####

*  1. strtok
 *  2. strerror
 *  3. memcpy
 *  4. memmove
 *  5. memcmp
 *  6. memset

## 1. strtok ##

![在这里插入图片描述][94664e6c3987425db28955725592cbd6.png]

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

代码演示

#include <stdio.h>
    #include <string.h>
    int main()
    {
        
    	char arr[] = "hehe@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;
    }

> 但是呢，这个代码写的不太好，如果要有很多分隔符就要写很多个print发，代码冗余会非常严重，那么就要用到循环了，下面来改进一下这个代码

#include <stdio.h>
    #include <string.h>
    int main()
    {
        
    	char arr[] = "hehe@yeah.net";
    		char buf[30] = {
         0 };//hehe\0yeah\0net\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;
    }

运行结果：  
![在这里插入图片描述][fa15f253699742be9766e6091d4f1602.png]

> strtok函数具有记忆功能

## 2. strerror ##

![在这里插入图片描述][12d10298a58d4246a37c876b456e661c.png]

> 返回错误码，所对应的错误信息。

演示结果：  
![在这里插入图片描述][2b930c108a704b609708abec50596748.png]

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

代码演示：

#include <stdio.h>
    #include <string.h>
    #include <errno.h>//使用errno必须要包含的头文件
    
    int main()
    {
        
    	//打开文件
    	//打开文件的时候，如果文件的打开方式是"r"
    	//文件存在则打开成功，文件不存在打开失败
    	//打开文件失败的话，会返回NULL
    	FILE* pf = fopen("test.txt", "r");
    	if (pf == NULL)
    	{
        
    		printf("打开文件失败，原因是：%s\n", strerror(errno));
    		return 1;
    	}
    	//读写文件
    	//...省略
    	//关闭文件
    	fclose(pf);
    	pf = NULL;
    	return 0;
    }

运行结果：  
![在这里插入图片描述][e7159a29387747e59a3831d16bc1590e.png]

> **这里我们有一个函数更直接：perror**  
> ![在这里插入图片描述][ed551db2885c45b5a2409410b45da451.png]

代码演示：

#include <stdio.h>
    #include <string.h>
    #include <errno.h>
    int main()
    {
        
    	//打开文件
    	//打开文件的时候，如果文件的打开方式是"r"
    	//文件存在则打开成功，文件不存在打开失败
    	//打开文件失败的话，会返回NULL
    	FILE* pf = fopen("test.txt", "r");
    	if (pf == NULL)
    	{
        
    		perror("打开文件失败");
    		//printf + strerror
    		return 1;
    	}
    	//读写文件
    	//...
    	//关闭文件
    	fclose(pf);
    	pf = NULL;
    	return 0;
    }

运行结果：  
![在这里插入图片描述][f6b9ac2cafe54ffd9fef2d1e45b42fa6.png]  
**字符分类函数：**  
![在这里插入图片描述][f133c5045b8e4bf9a0d220a2c90444dd.jpeg_pic_center]  
**字符转换：**

> int tolower ( int c );  
> int toupper ( int c );

#include <stdio.h>
    #include <ctype.h>
    int main()
    {
        
    	int i = 0;
    	char str[] = "Test String.\n";
    	char c;
    	while (str[i])
    	{
        
    		c = str[i];
    		if (isupper(c))
    			c = tolower(c);
    		putchar(c);
    		i++;
    	}
    	return 0;
    }

运行结果：  
![在这里插入图片描述][ed0ff5d50a584e3897d8189047f8303f.png]

## 3. memcpy ##

![在这里插入图片描述][6d1d376f668c4b649fd594fb44e763a9.png]

> memcpy内存拷贝函数，针对各种类型的数据进行拷贝，而strcpy只针对字符串，只能对字符串进行拷贝

**通过调试进行观察：**  
![在这里插入图片描述][aa7342cbd9be4453b393e7edeed8822e.png]

>  *  函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
>  *  这个函数在遇到 ‘\\0’ 的时候并不会停下来。
>  *  如果source和destination有任何的重叠，复制的结果都是未定义的。

**注：**

> memcpy函数的设计者不知道未来程序员要用这个函数拷贝什么类型的数据，所以用void \* 来修饰函数的参数（因为void \* 是通用类型的指针，可以接收任意类型数据的地址）

**memcpy函数的模拟实现**

#include <stdio.h>
    #include <assert.h>
    //mempcy函数返回的是目标空间的起始地址
    void* my_memcpy(void* dest, const void* src, size_t num)
    {
        
    	void* ret = dest;
    	assert(dest && src);
    	while (num--)
    	{
        
    		*(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;
    }

![在这里插入图片描述][7c18cc91721f4ef9b04221e143887134.png]

> 通过调试而观察到的运行结果

当内存重叠的时候打印效果

void* my_memcpy(void* dest, const void* src, size_t num)
    {
        
    	void* ret = dest;
    	assert(dest && src);
    	while (num--)
    	{
        
    		*(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 };
    	//             1 2 1 2 3 4 5 8 9 10  想把1 2 3拷贝放到3 4 5 的位置上时
    	my_memcpy(arr1+2, arr1, 20);
    	int i = 0;
    	for (i = 0; i < 10; i++)
    	{
        
    		printf("%d ", arr1[i]);
    	}
    }
    int main()
    {
        
    	test4();
    	return 0;
    }

打印结果：  
![在这里插入图片描述][e91973f6fd984e73a5a9ab426acadda3.png]

> 我们发现打印结果并不是我们预期的结果  
> 画图理解：  
> ![在这里插入图片描述][ce87f07dea2c460493bd1d694bb8f532.png]  
> 所以我们发现，在内存重叠的时候，使用memcpy可能出现意想不到的效果  
> 建议：在内存重叠的时候使用 memmove函数

## 4. memmove ##

![在这里插入图片描述][dbbd8ac06fee46f3949bab082425d8bf.png]

>  *  和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
>  *  如果源空间和目标空间出现重叠，就得使用memmove函数处理。

代码演示：

#include <stdio.h>
    #include <string.h>
    void test4()
    {
        
    	int arr1[] = {
         1,2,3,4,5,6,7,8,9,10 };
    	//             1 2 1 2 3 4 5 8 9 10  想把1 2 3拷贝放到3 4 5 的位置上时
    	memmove(arr1+2, arr1, 20);
    	int i = 0;
    	for (i = 0; i < 10; i++)
    	{
        
    		printf("%d ", arr1[i]);
    	}
    }
    int main()
    {
        
    	test4();
    	return 0;
    }

运行结果：  
![在这里插入图片描述][7b403c9bfc504143ae3e291762a1cf91.png]  
**模拟实现**

拷贝方向由后向前和由前向后如何区分  
![在这里插入图片描述][52f2040222224c13a26672fa70e3567d.png]

> ![这里是引用][5e88803ace8f4c88bd0cf3c26752ff6b.png]  
> 如果dest在1区域，从前向后，  
> 如果dest在2区域，从后向前，  
> 如果dest在3区域，从前向后或从后向前都可以  
> 建立选择关系如下：  
> ![在这里插入图片描述][0c02c6e0f4474e138c941ba52a39d2cc.png]

代码演示：

#include <stdio.h>
    #include <string.h>
    #include <assert.h>
    void* my_memmove(void* dest, const void* src, size_t num)
    {
        
    	void* ret = dest;
    	assert(dest && src);
    	if (dest < src)
    	{
        
    		//前->后
    		while (num--)
    		{
        
    			*(char*)dest = *(char*)src;
    			dest = (char*)dest + 1;
    			src = (char*)src + 1;
    		}
    	}
    	else
    	{
        
    		//后->前
    		while (num--)
    		{
        
    			*((char*)dest + num) = *((char*)src + num);
    		}
    	}
    	return ret;
    }
    void test4()
    {
        
    	int arr1[] = {
         1,2,3,4,5,6,7,8,9,10 };
    	//             1 2 1 2 3 4 5 8 9 10
    	my_memmove(arr1 + 2, arr1, 20);
    	int i = 0;
    	for (i = 0; i < 10; i++)
    	{
        
    		printf("%d ", arr1[i]);
    	}
    }
    int main()
    {
        
    	test4();
    	return 0;
    }

> C语言：memcpy拷贝不重叠的内存  
> 重叠的就交给memmove  
> memmove > memcpy（简单理解）  
> 100 60  
> VS:100 100（但是在vs里 memmove 与 memcpy的实现功能基本相同）

## 5. memcmp ##

![在这里插入图片描述][bf984be6037e4dd891a7f6e4864266d4.png]

> 内存比较函数  
> 比较从ptr1和ptr2指针开始的num个字节  
> 返回值如下：  
> ![在这里插入图片描述][a65495fe75894fa18dabb19e8eb1fcb3.png]

代码演示：

#include <stdio.h>
    void test5()
    {
        
    	int arr1[] = {
         1,2,3,4,7 };
    	//01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 07 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;
    }

运行结果：  
![在这里插入图片描述][ccde6e59488e4e1787f4cd360cf3aecb.png]

## 6. memset ##

> 内存设置函数：  
> 在设置的时候以字节为单位来设置数据![在这里插入图片描述][9c4c209633be480998cea1b44f54c6a6.png]

代码演示：

#include <stdio.h>
    void test6()
    {
        
    	char arr[] = "hello world";
    	memset(arr, 'x', 5);
    	printf("%s\n", arr);
    }
    int main()
    {
        
    	
    	test6();
    	return 0;
    }

运行结果：  
![在这里插入图片描述][55108338382842f7a59c1659dafee715.png]

> 关于字符函数和字符串函数的讲解七七就介绍到这里了，如果这篇文章对大家有帮助，请佬佬们点个赞再走吧！如果发现什么问题，欢迎评论区留言！  
> ![在这里插入图片描述][70112f552ef44841a44903d7a3d2398a.jpeg_pic_center]

[94664e6c3987425db28955725592cbd6.png]: https://img-blog.csdnimg.cn/94664e6c3987425db28955725592cbd6.png
[fa15f253699742be9766e6091d4f1602.png]: https://img-blog.csdnimg.cn/fa15f253699742be9766e6091d4f1602.png
[12d10298a58d4246a37c876b456e661c.png]: https://img-blog.csdnimg.cn/12d10298a58d4246a37c876b456e661c.png
[2b930c108a704b609708abec50596748.png]: https://img-blog.csdnimg.cn/2b930c108a704b609708abec50596748.png
[e7159a29387747e59a3831d16bc1590e.png]: https://img-blog.csdnimg.cn/e7159a29387747e59a3831d16bc1590e.png
[ed551db2885c45b5a2409410b45da451.png]: https://img-blog.csdnimg.cn/ed551db2885c45b5a2409410b45da451.png
[f6b9ac2cafe54ffd9fef2d1e45b42fa6.png]: https://img-blog.csdnimg.cn/f6b9ac2cafe54ffd9fef2d1e45b42fa6.png
[f133c5045b8e4bf9a0d220a2c90444dd.jpeg_pic_center]: https://img-blog.csdnimg.cn/f133c5045b8e4bf9a0d220a2c90444dd.jpeg#pic_center
[ed0ff5d50a584e3897d8189047f8303f.png]: https://img-blog.csdnimg.cn/ed0ff5d50a584e3897d8189047f8303f.png
[6d1d376f668c4b649fd594fb44e763a9.png]: https://img-blog.csdnimg.cn/6d1d376f668c4b649fd594fb44e763a9.png
[aa7342cbd9be4453b393e7edeed8822e.png]: https://img-blog.csdnimg.cn/aa7342cbd9be4453b393e7edeed8822e.png
[7c18cc91721f4ef9b04221e143887134.png]: https://img-blog.csdnimg.cn/7c18cc91721f4ef9b04221e143887134.png
[e91973f6fd984e73a5a9ab426acadda3.png]: https://img-blog.csdnimg.cn/e91973f6fd984e73a5a9ab426acadda3.png
[ce87f07dea2c460493bd1d694bb8f532.png]: https://img-blog.csdnimg.cn/ce87f07dea2c460493bd1d694bb8f532.png
[dbbd8ac06fee46f3949bab082425d8bf.png]: https://img-blog.csdnimg.cn/dbbd8ac06fee46f3949bab082425d8bf.png
[7b403c9bfc504143ae3e291762a1cf91.png]: https://img-blog.csdnimg.cn/7b403c9bfc504143ae3e291762a1cf91.png
[52f2040222224c13a26672fa70e3567d.png]: https://img-blog.csdnimg.cn/52f2040222224c13a26672fa70e3567d.png
[5e88803ace8f4c88bd0cf3c26752ff6b.png]: https://img-blog.csdnimg.cn/5e88803ace8f4c88bd0cf3c26752ff6b.png
[0c02c6e0f4474e138c941ba52a39d2cc.png]: https://img-blog.csdnimg.cn/0c02c6e0f4474e138c941ba52a39d2cc.png
[bf984be6037e4dd891a7f6e4864266d4.png]: https://img-blog.csdnimg.cn/bf984be6037e4dd891a7f6e4864266d4.png
[a65495fe75894fa18dabb19e8eb1fcb3.png]: https://img-blog.csdnimg.cn/a65495fe75894fa18dabb19e8eb1fcb3.png
[ccde6e59488e4e1787f4cd360cf3aecb.png]: https://img-blog.csdnimg.cn/ccde6e59488e4e1787f4cd360cf3aecb.png
[9c4c209633be480998cea1b44f54c6a6.png]: https://img-blog.csdnimg.cn/9c4c209633be480998cea1b44f54c6a6.png
[55108338382842f7a59c1659dafee715.png]: https://img-blog.csdnimg.cn/55108338382842f7a59c1659dafee715.png
[70112f552ef44841a44903d7a3d2398a.jpeg_pic_center]: https://img-blog.csdnimg.cn/70112f552ef44841a44903d7a3d2398a.jpeg#pic_center