C语言中的字符与字符串库函数的使用以及模拟实现

港控/mmm° 2023-10-05 23:02 17阅读 0赞

**目录**

一、求字符串长度

1、strlen库函数如何使用？

2.如何模拟实现strlen函数

二、长度不受限制的字符串函数

1.库函数 strcpy 如何使用？

2.如何模拟实现 strcpy 函数？

3.库函数 strcmp 如何实现？

4.strcmp 函数如何模拟实现？

5. 库函数 strcat 的使用

6. 如何模拟实现 strcat

三、长度受限制的字符串函数

1. strncpy - 长度受限制的字符串拷贝函数

2.strncat - 长度受限制的字符串追加函数

3.strncmp - 长度受限制的字符串比较函数

四、字符串查找

1.strstr 如何使用呢？

2.strstr 模拟实现

3.strtok 字符串切割函数

五、错误信息报告

六、字符操作

七、内存操作函数

1.memcpy内存拷贝函数如何使用呢？

2.模拟实现 memcpy

3.重叠内存之间的数据拷贝

4.memmove 模拟实现

5.内存比较

6.内存设置

--------------------

## 一、求字符串长度 ##

**strlen**：专门用来求字符串长度的函数（这里的长度指的是字符串字符的个数）。

###  ###

### 1、strlen库函数如何使用？ ###

#include<stdio.h>
    #include<string.h>
    
    int main()
    {
        char arr[] = "abcdef";
        int len = strlen(arr);
        printf("%d\n", len);
        return 0;
    }

输出结果：

![c35eb5c66b1846408a53cb822176245b.png][]

![0022852ef9f64117a9c472b6b1883fc1.png][]

为什么会输出 6 呢？

解释：

**strlen** 从arr数组的第一个字符开始计算，遇到一个字符，个数加1，直到计算所有的字符后结束。

![e30be5c221d640adabbf3ac24a85f7e1.png][]

注意：字符串的结束标志是 '\\0' ，计算字符串长度时不会计算 '\\0' ，只会计算 '\\0' 之前的字符。

**strlen库函数的使用需要引用头文件！**

![3ad322e799494e13843ee1be7c5e075d.png][]

### 2.如何模拟实现strlen函数 ###

#include<stdio.h>
    #include<assert.h>
    
    size_t my_strlen(const char* arr)
    {
    	assert(arr);
    	size_t count = 0;
    	while (*arr != '\0')
    	{
    		count++;
    		arr++;
    	}
    	return count;
    }
    
    int main()
    {
    	char arr[] = "abcdef";
    	int ret = my_strlen(arr);
    	printf("%d\n", ret);
    	return 0;
    }

这个代码求的是arr数组的长度，结果是6。

assert(arr);这一句是断言，为的是确保数组首元素的地址传过来的时候不是一个 **NULL** 。

assert 函数的头文件：

![afce96cc59c14eb59cf4bcb9d461df0a.png][]

**count** 记录的是字符个数，所以返回 **count** 就是返回字符串长度。

## 二、长度不受限制的字符串函数 ##

**strcpy：**字符串拷贝函数，专门用来拷贝字符串内容的函数。（将源空间的内容拷贝到目标空间）

###  ###

### 1.库函数 **strcpy** 如何使用？ ###

#include<stdio.h>
    #include<string.h>
    
    int main()
    {
    	char arr1[20] = { 0 };
    	char arr2[] = "I love China!";
    	strcpy(arr1, arr2);
    	printf("%s\n", arr1);
    	return 0;
    }

**strcpy** 的第一个参数（arr1）表示目标空间，第二个参数（arr2）表示源空间。

它的头文件是：

![9129c0ad50c44e2daa3c63f372c75571.png][]

代码的作用是将字符串 "I love China!" 拷贝到arr1中并打印出来。

输出结果：![eacd31cdc462497eb5c8c566365e6d77.png][]

![e30be5c221d640adabbf3ac24a85f7e1.png][]

注意：**strcpy** 只是将目标空间的内容覆盖，自身源空间的内容并不会改变。

###  ###

### 2.如何模拟实现 **strcpy** 函数？ ###

#include<stdio.h>
    #include<assert.h>
    
    char* my_strcpy(char* dest, const char* src)
    {
    	assert(dest && src);
    	char* ret = dest;
    	while (*src)
    	{
    		*dest++ = *src++;
    	}
    	*dest = *src;//'\0'
    	return ret;
    }
    
    int main()
    {
    	char arr1[20] = { 0 };
    	char arr2[] = "I love China!";
    	my_strcpy(arr1, arr2);
    	printf("%s\n", arr1);
    	return 0;
    }

我们并不会改变源空间，所以加上 **const** 在我们不小心将其修改的时候对其进行保护。

代码的含义是：

先将 **dest** 最开始指向的内容赋给 ret ，作为目标空间起始地址；**\*dest++ = \*src++;** 是将目标空间的字符给改成源空间的字符，直到源空间的字符全部改完。++ 就是指向下一个内容；**src** 是源空间拷贝结束后会指向 arr2 末尾的 '\\0'，**\*dest = \*src;** 就是将此时 **src** 指向的内是('\\0') **dest**。

### 3.库函数 strcmp 如何实现？ ###

**strcmp:** 字符串比较函数，专门用来比较字符串内容的函数。

![e30be5c221d640adabbf3ac24a85f7e1.png][]

注意：字符串比较，比的是相同位置字符的 **ASCII** 码值的大小

例如：

char arr1[] = "abcde";
    char arr2[] = "abcfg";

a, b, c 的 ASCII 码值一样大，所以前三个字符是相同大小的，比到第4个字符的时候，f 的 ASCII 码值大于 d ，所以 **arr2 要大于 arr1** 。

![23bae93bb9d54394914a00387f2cb380.png][]

这个函数有两个参数，分别是要比较的字符串的地址。返回类型是 **int 。**

![e35306e1a59e4221be6f8ed90d04b197.png][]

**返回值的解释：**

如果第一个字符串小于第二个字符串，就返回 **小于0** 的数字；如果第一个字符串等于第二个字符串，就返回 **0** ；如果第一个字符串大于第二个字符串，就返回 **大于0** 的数字；

#include<stdio.h>
    #include<string.h>
    
    int main()
    {
    	char arr1[] = "abcdef";
    	char arr2[] = "abc";
    	int ret = strcmp(arr1, arr2);
    	if (0 > ret)
    	{
    		printf("arr1 < arr2");
    	}
    	else if (0 == ret)
    	{
    		printf("arr1 == arr2");
    	}
    	else
    	{
    		printf("arr1 > arr2");
    	}
    	return 0;
    }

**strcmp** 的头文件

![de0fd836ee04463fbe71f9beef260b67.png][]

输出结果：

![83c9714a5b6942a28771b5ca845f1244.png][]

### 4.strcmp 函数如何模拟实现？ ###

#include<stdio.h>
    #include<assert.h>
    
    int  my_strcmp(const char* arr1, const char* arr2)
    {
    	assert(arr1 && arr2);
    	while (*arr1 == *arr2)
    	{
    		//等于的情况
    		if (*arr1 == '\0')
    		{
    			return 0;
    		}
    		arr1++;
    		arr2++;
    	}
    	return (*arr1 - *arr2);
    }
    
    int main()
    {
    	char arr1[] = "abcd";
    	char arr2[] = "abcd";
    	int ret = my_strcmp(arr1, arr2);
    	if (ret < 0)
    	{
    		printf("arr2 < arr1");
    	}
    	else if (ret == 0)
    	{
    		printf("arr2 == arr1");
    	}
    	else
    	{
    		printf("arr2 > arr1");
    	}
    	printf("%d\n", ret);
    	return 0;
    }

当比较的字符相等时而且还未遇到结尾，循环和 ++ 操作符就可以指向下一个字符并比较，直到遇到末尾的 \\0 。如果arr1指向了 \\0 则说明两个字符串的所有字符都比较过了，结果还是相等，然后返回0。当比较出大小的时候，就返回 **arr1 指向的内容减去 arr2 指向的内容**。如果 arr1 大于 arr2 ，返回的就是大于 0 的数字，反之就是小于。

![ea61660cf2ea4dadafdc0d935c9eca9b.png][]

长度不受限制就是再使用的时候，不能限制进行操作的字符个数，一直操作到 \\0 为止；长度受限制相反，我们可以限制操作的字符个数。

![71ff671461ce47d59c1fd58926db5a4c.png][]

**在使用的时候建议使用长度受限制的字符串函数，因为当目标空间不够的时候，我们进行字符串拷贝、追加会因为空间不够而造成出错。**

### 5. 库函数 strcat 的使用 ###

**strcat :** 字符串追加函数，专门用来追加字符串内容的函数。（将一段字符追加到目标空间）

**strcat** 的头文件

![84d7aea731454cd4bbba723e5524aadc.png][]

#include<stdio.h>
    #include<string.h>
    
    int main()
    {
    	char arr[20] = "hello ";
    	strcat(arr, "world");
    	printf("%s\n", arr);
    	return 0;
    }

代码的作用是将 **world** 追加到 arr 字符串的末尾。

输出结果：

![f9af3435a12e464dad8b48398c7c3dfc.png][]

### 6. 如何模拟实现 strcat ###

#include<stdio.h>
    #include<assert.h>
    
    char* my_strcat(char* dest, const char* src)
    {
    	assert(dest && src);
    	char* ret = dest;
    	while (*dest != '\0')
    	{
    		dest++;
    	}
    	while (*dest++ = *src++)
    	{
    		;
    	}
    	return ret;
    }
    
    int main()
    {
    	char arr[20] = "hello ";
    	my_strcat(arr, "world");
    	printf("%s\n", arr);
    	return 0;
    }

第**一个参数依然是表示目标空间**，**第二个参数表示源空间**，代码的作用是将源空间的每一个字符都拷贝到目标空间，这和 strcpy 有些类似。

![6a0e7400fab94524a56fc2e8b850bc64.png][]

第一个循环为的是找到目标字符串的结尾，第二个循环为的是将源空间的字符拷贝到目标字符串的后面。

## 三、长度受限制的字符串函数 ##

### **1. strncpy -** 长度受限制的字符串拷贝函数 ###

![db920290da5d4423a668b2ed750e7265.png][]

这个函数的参数有三个，前两个是要操作的字符串，**第三个参数是你要拷贝多少个字节。**

#include<stdio.h>
    #include<string.h>
    
    int main()
    {
    	char arr1[] = "hello";
    	char arr2[] = "abcdefg";
    	strncpy(arr1, arr2, 5);
    	printf("%s", arr1);
    	return 0;
    }

arr1是目标空间， arr2是源空间，5是要拷贝的字节数，因为一个字符是一个字节；所以这段代码的含义是：将 **arr2** 数组的前5个字符拷贝到 **arr1** 数组中。

代码结果：

![3715039907fd45d88964016719728979.png][]

![e30be5c221d640adabbf3ac24a85f7e1.png][]

注意：当我们要拷贝的字节数大于源空间的字节数时，差几个字节就拷贝几个 '\\0' 到目标空间去。

![a266ca88ed574090b0be4118524b5da9.png][]

### 2.strncat - 长度受限制的字符串追加函数 ###

![50ba64f8e8424203a03bbbbeffb6fc51.png][]

这个函数的参数有三个，前两个是要操作的字符串，**第三个参数是你要追加多少个字节。**

#include<stdio.h>
    #include<string.h>
    
    int main()
    {
    	char arr1[20] = "hello ";
    	char arr2[] = "world";
    	strncat(arr1, arr2, 5);
    	printf("%s", arr1);
    	return 0;
    }

代码结果：

![cd7690db10704d3fb7c14206787de7c0.png][]

arr1是目标空间， arr2是源空间，5是要追加的字节数，因为一个字符是一个字节；所以这段代码的含义是：将 **arr2** 数组的5个字符追加到 **arr1** 数组中。

![e30be5c221d640adabbf3ac24a85f7e1.png][]

注意： 值得注意的是在要追加的内容完成后还会追加一个 **\\0** ，因为补上一个 \\0 才能是作为一个字符串存在。

![a5984dcf24044b11a439baba9bfa1c4b.png][]

![e30be5c221d640adabbf3ac24a85f7e1.png][]

注意：当我们要拷贝的字节数大于源空间的字节数时，不会像strcpy那样拷贝 \\0 过去。

### 3.strncmp - 长度受限制的字符串比较函数 ###

![264b12291b544c64b4da79a6058e0870.png][]

这个函数的参数也有三个，前两个是要比较的字符串，**第三个参数是你要比较多少个字节。**

#include<stdio.h>
    #include<string.h>
    
    int main()
    {
    	char arr1[20] = "abcdef";
    	char arr2[] = "abcdf";
    	int ret = strncmp(arr1, arr2, 5);
    	if (ret > 0)
    	{
    		printf("arr1 > arr2");
    	}
    	else if (ret < 0)
    	{
    		printf("arr1 < arr2");
    	}
    	else
    	{
    		printf("arr1 == arr2");
    	}
    	return 0;
    }

arr1是要比较的第一个字符串， arr2是要比较的第二个字符串，5是要比较的字节数，因为一个字符是一个字节；所以这段代码的含义是：比较 **arr2** 和 **arr1** 数组的前5个字符的大小。

代码结果：

![5ab3ac9ba0924edd9c91f4c5f7c55d1c.png][]

## 四、字符串查找 ##

**strstr** ：是一个查找子串的函数，就是在一个字符串中查找了一个字符串存不存在。

### 1.strstr 如何使用呢？ ###

![bfb17ef4f5414559aaabbc8c3aaba8dc.png][]

这个函数有两个参数，第一个参数是比较长的串，第二个是子串；函数的目的是要在这个比较长的串中查找子串是否存在。如果找到了子串会返回子串在长串的起始位置，找不到则返回一个空指针

#include<stdio.h>
    #include<string.h>
    
    int main()
    {
    	char arr1[] = "abcdefg";
    	char arr2[] = "cde";
    	char* ret = strstr(arr1, arr2);
    	if (ret == NULL)
    	{
    		printf("子串不存在\n");
    	}
    	else
    	{
    		printf("%s\n", ret);
    	}
    	return 0;
    }

子串如果存在，代码会打印从子串起始位置到 \\0 的字符。

strstr 的头文件：

![5de5835e530a4d9884e1fd368202e4a1.png][]

代码结果：

![fab9ae4eb0054cdb9fec062002543c1e.png][]

### 2.strstr 模拟实现 ###

可能遇到的两种情况：

情况1

这一种情况是最简单的。

![2bd0bf98bd4e49609453e00df5b1bb96.png][]

情况2

![073f00034fe74d97b1f4f82b44fbb104.png][]

值得注意的是，当s2全都对比过后还没有查找到，而且s1还有字符为对比过，则就要把s2重置到起始位置，把s1重置到第一次与s2相等的后面的字符，然后从这里开始对比，直到结束。

代码实现：

#include<stdio.h>
    #include<string.h>
    #include<assert.h>
    
    char* my_strstr(const char* str1, const char* str2)
    {
    	assert(str1 && str2);
    	const char* p = str1;
    	const char* s1 = str1;
    	const char* s2 = str2;
    	while (*p)
    	{
    		s1 = p;
    		s2 = str2;
    		while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2)
    		{
    			s1++;
    			s2++;
    		}
    		if (*s2 == '\0')
    		{
    			return (char*)p;
    		}
    		p++;
    	}
    	return NULL;
    }
    
    int main()
    {
    	char arr1[] = "abcdefg";
    	char arr2[] = "cde";
    	char* ret = my_strstr(arr1, arr2);
    	if (ret == NULL)
    	{
    		printf("子串不存在\n");
    	}
    	else
    	{
    		printf("%s\n", ret);
    	}
    	return 0;
    }

### 3.strtok 字符串切割函数 ###

字符串切割函数，把你想要的内容给切割出来。

![1f20aa4462bf4f8ab6667603a12a93e4.png][]

这个函数有两个参数，返回类型是 **char\***，

*  sep 参数是是个字符串，定义了用作分隔符的字符集合。

这一点是什么意思呢？

#include<stdio.h>
    #include<string.h>
    #include<assert.h>
    
    int main()
    {
    	//假设是这个字符串：abcdefg@lilong.com
    	char* sep = "@.";//@ 和 . 就是分隔符
    	return 0;
    }

*  第一个参数指定一个字符串，它包含了 0 个或者多个由 sep 字符串中的一个或者多个分隔符分割的标记。
 *  strtok函数找到str中的下一个，并蒋用大学结，的课指向这个标记的指针。 (注：strtok 函数会改变被操作的字符串，所以**在使用 strtok 函数切分的字符串一般都是临时拷贝的内容并且可修改**。)

这一点是什么意思呢？

![d2cb510552ee41d489e615b09c2d55e6.png][]

会返回 \\0 之前的字符串。

*  strtok 函数的第一个参数不为 **NULL**，函数将找到str中第一个标记，strtok 函数将保存它在字符串中的位置。
 *  strtok 函数的第一个参数为 **NULL**，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
 *  如果字符串中不存在更多的标记，则返回NULL指针。

头文件是 **<string.h>**

![90fd01e5275d406fa7387181cf3ee6f2.png][]

#include<stdio.h>
    #include<string.h>
    
    int main()
    {
    	//假设是这个字符串：abcdefg@lilong.com
    	const char* sep = "@.";//@ 和 . 就是分隔符
    	char str[] = "abcdefg@lilong.com";
    	char cp[30] = { 0 };
    	strcpy(cp, str);
    
    	char* ret = NULL;
    	for (ret = strtok(cp, sep); ret != NULL; ret = strtok(NULL, sep))
    	{
    		printf("%s\n", ret);
    	}
    	return 0;
    }

代码结果：

![681df67944bf4d3cb398c869d9fae7cb.png][]

## 五、错误信息报告 ##

**strerror** ：错误信息报告函数，返回错误码，所对应的信息。

函数的参数及返回类型

![547ffde75a914f96a14fb57f92d6d59b.png][]

![4b6626c661354868a87ef25d92bc0671.png][]

#include<stdio.h>
    #include<string.h>
    #include<errno.h>
    
    //errno - 是C语言设置的一个全局的错误码存放的变量
    int main()
    {
        //"r" - 以读的形式打开 "test.txt" 这个文件
    	FILE* pf = fopen("test.txt", "r");
    	if (NULL == pf)
    	{
    		printf("%s\n", strerror(errno));
            //使用errno是需要引用头文件<errno.h>
    		return 1;
    	}
    	else
    	{
    		printf("haha\n");
    	}
    	return 0;
    }

因为文件不存在，所以strerror 函数会返回一个错误信息。

代码结果：

![216fbc3c74864a2493483b00aa3179a0.png][]

## 六、字符操作 ##

字符分类函数

> iscntrl：如何控制字符
> 
> isspace：空白字符：空格' '、换页'\\f'、换行'\\n'、回车'\\r'、制表符'\\t'或者垂直制表符'\\v'
> 
> isdigit：十进制数字 0~9
> 
> isxdigit：十六进制数字，不搜阔所以十进制数字，小写字母 a~f、大写字母 A~F
> 
> islower：小写字母 a~z
> 
> isupper：大写字母 A~Z
> 
> isalpha：字母a~z 或者 A~Z
> 
> isalnum：字母或者数字，a~z、A~Z、0~9
> 
> ispunct：标点符号，任何不属于数字或者字母的图形字符（可打印）
> 
> isgraph：任何图形字符
> 
> isprint：任何可打印字符，包括图形字符和空白字符

因为这些函数使用起来比较简单，这里就不一一介绍了。大家可以去 **cplusplus.com** 这个网站查看；也可以使用 **MSDN** 来查看。

字符转换函数：

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

#include<stdio.h>
    #include<ctype.h>
    
    int main()
    {
    	printf("%c\n", tolower('A'));
        //将大写字母转化为小写
    	return 0;
    }

![c3bf45238a5d4359ab235dc4e85a5e50.png][]

## 七、内存操作函数 ##

### 1.**memcpy**内存拷贝函数如何使用呢？ ###

**memcpy：**内存拷贝函数

当不确定要拷贝内容的类型是什么的时候。可以把内存拷贝过去，这样不管是什么类型都可以拷贝。不用 strcpy 是因为它是字符串的拷贝函数，只能用来拷贝字符串。

![80827c181077435d9c474bbf0124efe1.png][]

**num** 表示要拷贝多少个字节的内容，**source** 表示源空间，**destination** 表示目标空间。

#include<stdio.h>
    #include<string.h>
    
    int main()
    {
    	int src[] = { 1,2,3,4,5 };
    	int dest[10] = { 0 };
    	memcpy(dest, src, sizeof(src));
    	return 0;
    }

代码结果：![1e6a9903a3a143619fe731e1b6cb447d.png][]

src 里的内容拷贝成功！

**为什么这个函数的参数和返回类型是 void\* 呢？**

因为 **void\*** 是一个泛型指针，它的通用高，当不确定是什么类型的时候使用它更加方便快捷。

### 2.模拟实现 memcpy ###

拷贝的数据是 **int** 类型的，但是这里为什么要使用 **char\*** 来强制类型转换呢？

> 一个整形4个字节，如果强转为 int\* 只能一次性拷贝4个字节，但如果要拷贝3个、11个或者是21个的（4的倍数）时候 int\* 明显不合适，这个时候就可以使用最细致的 char\* ，一次拷贝一个字节，通用型更强。

**memcpy** 是不用来处理重叠的内存之间的数据拷贝的

### 3.重叠内存之间的数据拷贝 ###

**memmove** ：也是一个内存拷贝函数，但是可以拷贝重叠内存之间的数据。

这是他的返回类型、参数和头文件

![4cf7183829c8461cbff23258d36ac5b8.png][]值得注意的是它与 ，**memcpy** 的参数一样 。都是目标空间、源空间、和要拷贝的字节数。说明它的用法也是一样的。

下面的代码目的是将 **1、2、3、4、5** 拷贝到 **3、4、5、6、7** 上去，但是实际的结果是什么呢？

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

代码结果：

![fe1c8cca7768468b97dc65ea3582f323.png][]

如果拷贝成功了，代码的结果应该是：

> 1 2 1 2 3 4 5 8 9 10

那为什么会出错呢？

> 是因为 memcpy 不能拷贝重叠内存之间的数据，要使用memmove来拷贝

![7733a7565c0e479f973fed826f6a4d7d.png][]

**memmove** 库函数的使用方法：

#include<stdio.h>
    #include<assert.h>
    #include<string.h>
    
    void test2()
    {
    	int src[] = { 1,2,3,4,5,6,7,8,9,10 };
    	memmove(src + 2, src, 20);
    	int i = 0;
    	for (i = 0; i < 10; i++)
    	{
    		printf("%d ", src[i]);
    	}
    }
    
    int main()
    {
    	test2();
    	return 0;
    }

代码结果：

![2d5a3d286fbe4e61b2694667d8040136.png][]

这次拷贝成功了。

### 4.**memmove** 模拟实现 ###

在实现 **memmove** 会出现三种情况。

第一种：**从前往后处理数据**

![c507f225eefc404295d10cd980c3c603.png][]

当 src 的起始地址在 dest 的起始地址左边的时候，就要采用**从前往后处理数据的方式**（先拷贝4，最后拷贝8）来避免数据重叠而带来的错误。

**第二种**：**从后往前处理数据**

![15e2cb4e94674e699c932fc77a9ce262.png][]

在 dest 的起始位置在 src 的范围内的时候，就要采用**从后往前处理数据的方式**（先拷贝5，最后拷贝1）来避免数据重叠而带来的错误。

**第三种：前往后，后往前任意**

![136448cbcd064c34bbf846a004dfaa89.png][]

在 dest 的起始位置不在 src 的范围内的时候，采用**前往后，后往前任意**

如果是第一种情况就采用 **前往后，**如果是第二、三两种情况就采用 **后往前**。

代码实现：

#include<stdio.h>
    #include<assert.h>
    
    void* my_memmove(void* dest, const void* src, size_t num)
    {
    	assert(dest && src);
    	void* ret = dest;
    	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 test()
    {
    	int src[] = { 1,2,3,4,5,6,7,8,9,10 };
    	my_memmove(src + 2, src, 20);
    	int i = 0;
    	for (i = 0; i < 10; i++)
    	{
    		printf("%d ", src[i]);
    	}
    }
    
    int main()
    {
    	test();
    	return 0;
    }

### 5.内存比较 ###

**memcmp** ：内存比较函数

参数、返回类型和头文件：

![796439e5365843a6879087b28b29abe4.png][]

**buf1** 和 **buf2** 指向两块空间，**count** 表示向后在 **count** 个字节内部比较。

如果要比较两块内存里的数据是否相同，就可以使用 **memcmp**

#include<stdio.h>
    #include<string.h>
    
    int main()
    {
    	int arr1[] = { 1,2,3 };
    	int arr2[] = { 1,3,2 };
    	int ret = memcmp(arr1, arr2, 12);
    	printf("%d\n", ret);
    	return 0;
    }

![159e57281a6347098fdfbd4b55721794.png][]

如果第一块内存大于第二块内存，返回一个大于0的数字； 如果第一块内存等于第二块内存，返回数字0； 如果第一块内存小于第二块内存，返回一个小于0的数字；

**memcmp** 也是一对一对比较的。

> arr1：01 00 00 00 02 00 00 00 03 00 00 00  
> arr2：01 00 00 00 03 00 00 00 02 00 00 00

一对比可以很明显的看出 arr1 小于 arr2 ，所以返回小于0的数字。

代码结果：

![4f51da4f6eae4f4e80821b22c6bc73cf.png][]

注意：

*  memcmp 可以比较字符串也可以比较任意类型的数据。
 *  memcmp 只有当参数中所有的字节都比较完后才会结束。

### 6.内存设置 ###

**memset** ：内存设置函数

参数、返回类型和头文件：

![78d08e27c7574f788022b402b7e12857.png][]

如果有一份数据等待着对他初始化，就可以使用 **memset** 。

**dest** 参数是设置的填充空间，**c** 参数是要设置的值，**count** 参数是要设置的值的字节数

例1：

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

代码的含义是将arr数组中的前5个字节的内容设置为字符x。

代码结果：

![6f454899eac742c7bd886b3b57b14f03.png][]

例2：

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

代码结果：

![3435c81ef02d43228a817b1314e498ea.png][]

[c35eb5c66b1846408a53cb822176245b.png]: https://img-blog.csdnimg.cn/c35eb5c66b1846408a53cb822176245b.png
[0022852ef9f64117a9c472b6b1883fc1.png]: https://img-blog.csdnimg.cn/0022852ef9f64117a9c472b6b1883fc1.png
[e30be5c221d640adabbf3ac24a85f7e1.png]: https://img-blog.csdnimg.cn/e30be5c221d640adabbf3ac24a85f7e1.png
[3ad322e799494e13843ee1be7c5e075d.png]: https://img-blog.csdnimg.cn/3ad322e799494e13843ee1be7c5e075d.png
[afce96cc59c14eb59cf4bcb9d461df0a.png]: https://img-blog.csdnimg.cn/afce96cc59c14eb59cf4bcb9d461df0a.png
[9129c0ad50c44e2daa3c63f372c75571.png]: https://img-blog.csdnimg.cn/9129c0ad50c44e2daa3c63f372c75571.png
[eacd31cdc462497eb5c8c566365e6d77.png]: https://img-blog.csdnimg.cn/eacd31cdc462497eb5c8c566365e6d77.png
[23bae93bb9d54394914a00387f2cb380.png]: https://img-blog.csdnimg.cn/23bae93bb9d54394914a00387f2cb380.png
[e35306e1a59e4221be6f8ed90d04b197.png]: https://img-blog.csdnimg.cn/e35306e1a59e4221be6f8ed90d04b197.png
[de0fd836ee04463fbe71f9beef260b67.png]: https://img-blog.csdnimg.cn/de0fd836ee04463fbe71f9beef260b67.png
[83c9714a5b6942a28771b5ca845f1244.png]: https://img-blog.csdnimg.cn/83c9714a5b6942a28771b5ca845f1244.png
[ea61660cf2ea4dadafdc0d935c9eca9b.png]: https://img-blog.csdnimg.cn/ea61660cf2ea4dadafdc0d935c9eca9b.png
[71ff671461ce47d59c1fd58926db5a4c.png]: https://img-blog.csdnimg.cn/71ff671461ce47d59c1fd58926db5a4c.png
[84d7aea731454cd4bbba723e5524aadc.png]: https://img-blog.csdnimg.cn/84d7aea731454cd4bbba723e5524aadc.png
[f9af3435a12e464dad8b48398c7c3dfc.png]: https://img-blog.csdnimg.cn/f9af3435a12e464dad8b48398c7c3dfc.png
[6a0e7400fab94524a56fc2e8b850bc64.png]: https://img-blog.csdnimg.cn/6a0e7400fab94524a56fc2e8b850bc64.png
[db920290da5d4423a668b2ed750e7265.png]: https://img-blog.csdnimg.cn/db920290da5d4423a668b2ed750e7265.png
[3715039907fd45d88964016719728979.png]: https://img-blog.csdnimg.cn/3715039907fd45d88964016719728979.png
[a266ca88ed574090b0be4118524b5da9.png]: https://img-blog.csdnimg.cn/a266ca88ed574090b0be4118524b5da9.png
[50ba64f8e8424203a03bbbbeffb6fc51.png]: https://img-blog.csdnimg.cn/50ba64f8e8424203a03bbbbeffb6fc51.png
[cd7690db10704d3fb7c14206787de7c0.png]: https://img-blog.csdnimg.cn/cd7690db10704d3fb7c14206787de7c0.png
[a5984dcf24044b11a439baba9bfa1c4b.png]: https://img-blog.csdnimg.cn/a5984dcf24044b11a439baba9bfa1c4b.png
[264b12291b544c64b4da79a6058e0870.png]: https://img-blog.csdnimg.cn/264b12291b544c64b4da79a6058e0870.png
[5ab3ac9ba0924edd9c91f4c5f7c55d1c.png]: https://img-blog.csdnimg.cn/5ab3ac9ba0924edd9c91f4c5f7c55d1c.png
[bfb17ef4f5414559aaabbc8c3aaba8dc.png]: https://img-blog.csdnimg.cn/bfb17ef4f5414559aaabbc8c3aaba8dc.png
[5de5835e530a4d9884e1fd368202e4a1.png]: https://img-blog.csdnimg.cn/5de5835e530a4d9884e1fd368202e4a1.png
[fab9ae4eb0054cdb9fec062002543c1e.png]: https://img-blog.csdnimg.cn/fab9ae4eb0054cdb9fec062002543c1e.png
[2bd0bf98bd4e49609453e00df5b1bb96.png]: https://img-blog.csdnimg.cn/2bd0bf98bd4e49609453e00df5b1bb96.png
[073f00034fe74d97b1f4f82b44fbb104.png]: https://img-blog.csdnimg.cn/073f00034fe74d97b1f4f82b44fbb104.png
[1f20aa4462bf4f8ab6667603a12a93e4.png]: https://img-blog.csdnimg.cn/1f20aa4462bf4f8ab6667603a12a93e4.png
[d2cb510552ee41d489e615b09c2d55e6.png]: https://img-blog.csdnimg.cn/d2cb510552ee41d489e615b09c2d55e6.png
[90fd01e5275d406fa7387181cf3ee6f2.png]: https://img-blog.csdnimg.cn/90fd01e5275d406fa7387181cf3ee6f2.png
[681df67944bf4d3cb398c869d9fae7cb.png]: https://img-blog.csdnimg.cn/681df67944bf4d3cb398c869d9fae7cb.png
[547ffde75a914f96a14fb57f92d6d59b.png]: https://img-blog.csdnimg.cn/547ffde75a914f96a14fb57f92d6d59b.png
[4b6626c661354868a87ef25d92bc0671.png]: https://img-blog.csdnimg.cn/4b6626c661354868a87ef25d92bc0671.png
[216fbc3c74864a2493483b00aa3179a0.png]: https://img-blog.csdnimg.cn/216fbc3c74864a2493483b00aa3179a0.png
[c3bf45238a5d4359ab235dc4e85a5e50.png]: https://img-blog.csdnimg.cn/c3bf45238a5d4359ab235dc4e85a5e50.png
[80827c181077435d9c474bbf0124efe1.png]: https://img-blog.csdnimg.cn/80827c181077435d9c474bbf0124efe1.png
[1e6a9903a3a143619fe731e1b6cb447d.png]: https://img-blog.csdnimg.cn/1e6a9903a3a143619fe731e1b6cb447d.png
[4cf7183829c8461cbff23258d36ac5b8.png]: https://img-blog.csdnimg.cn/4cf7183829c8461cbff23258d36ac5b8.png
[fe1c8cca7768468b97dc65ea3582f323.png]: https://img-blog.csdnimg.cn/fe1c8cca7768468b97dc65ea3582f323.png
[7733a7565c0e479f973fed826f6a4d7d.png]: https://img-blog.csdnimg.cn/7733a7565c0e479f973fed826f6a4d7d.png
[2d5a3d286fbe4e61b2694667d8040136.png]: https://img-blog.csdnimg.cn/2d5a3d286fbe4e61b2694667d8040136.png
[c507f225eefc404295d10cd980c3c603.png]: https://img-blog.csdnimg.cn/c507f225eefc404295d10cd980c3c603.png
[15e2cb4e94674e699c932fc77a9ce262.png]: https://img-blog.csdnimg.cn/15e2cb4e94674e699c932fc77a9ce262.png
[136448cbcd064c34bbf846a004dfaa89.png]: https://img-blog.csdnimg.cn/136448cbcd064c34bbf846a004dfaa89.png
[796439e5365843a6879087b28b29abe4.png]: https://img-blog.csdnimg.cn/796439e5365843a6879087b28b29abe4.png
[159e57281a6347098fdfbd4b55721794.png]: https://img-blog.csdnimg.cn/159e57281a6347098fdfbd4b55721794.png
[4f51da4f6eae4f4e80821b22c6bc73cf.png]: https://img-blog.csdnimg.cn/4f51da4f6eae4f4e80821b22c6bc73cf.png
[78d08e27c7574f788022b402b7e12857.png]: https://img-blog.csdnimg.cn/78d08e27c7574f788022b402b7e12857.png
[6f454899eac742c7bd886b3b57b14f03.png]: https://img-blog.csdnimg.cn/6f454899eac742c7bd886b3b57b14f03.png
[3435c81ef02d43228a817b1314e498ea.png]: https://img-blog.csdnimg.cn/3435c81ef02d43228a817b1314e498ea.png