【C语言】字符函数和字符串函数

前言

---

C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串中或者字符数组中。
 
字符串常量适用于那些对它不做修改的字符串函数。
 
📖：本章重点介绍处理字符和字符串的库函数的使用和注意事项

• 求字符串长度
  • strlen
• 长度不受限制的字符串函数
  • strcpy
  • strcat
  • strcmp
• 长度受限制的字符串函数
  • strncpy
  • strncat
  • strncmp
• 字符串查找
  • strstr
  • strtok
  • atoi
• 错误信息报告
  • strerror
  • perror
• 字符操作函数
• 内存操作函数
  • memcpy
  • memmove
  • memset
  • memcmp

 
 

1. 求字符串长度

---

1.1 strlen

函数strlen的返回类型和参数如下：

size_t strlen ( const char * str );

• 字符串已经 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包含 '\0' )。
• 参数指向的字符串必须要以 '\0' 结束。
• 注意函数的返回值为size_t，是无符号整形（ 易错 ）
  

来看一段代码：

#include <stdio.h>
#include <string.h>
int main()
{
	if (strlen("abc") - strlen("abcdef") > 0)
		printf("大于\n");
	else
		printf("小于等于\n");
	return 0;
}

这段代码大家可能都会想到的是$3-6<0$，结果输出的是：小于等于

 

但结果如图：

出现这样的原因正是因为strlen的返回值是无符号整型，两个无符号整形的数相减，结果也会被当做无符号数处理。

我们可以模仿一下strlen函数的实现：

#include <stdio.h>
#include <assert.h>
//版本一:计数
size_t my_strlen(const char* str)
{
	assert(str);
	size_t count = 0;
	while (*str++)
	{
		count++;
	}
	return count;
}
int main()
{
	char* p = "abcdefg";
	size_t len = my_strlen(p);
	printf("%zd\n", len);
	return 0;
}

//版本二:递归
size_t my_strlen(const char* str)
{
	assert(str);
	if (*str == '\0')
		return 0;
	else
		return 1 + my_strlen(str + 1);
}
int main()
{
	char* p = "abcdefg";
	size_t len = my_strlen(p);
	printf("%zd\n", len);
	return 0;
}

//版本三:指针 - 指针
size_t my_strlen(const char* str)
{
	assert(str);
	const char* left = str;
	int i = 0;
	while (*str++)
		;//这里循环结束,得到的地址是'\0'后一位的地址
	const char* right = str - 1;//得到'\0'的地址
	return (size_t)(right - left);//得到两个地址之间的元素个数
}
int main()
{
	char* p = "abcdefg";
	size_t len = my_strlen(p);
	printf("%zd\n", len);
	return 0;
}

 
 

2. 长度不受限制的字符串函数

---

2.1 strcpy

函数strcpy的返回类型和参数如下：

char * strcpy ( char * destination, const char * source );

-Copies the C string pointed by source into the array pointed by destination, including the terminating null character (and stopping at that point)… 译： 将源(source)指向的C字符串复制到目标(destination)指向的数组中，包括终止的空字符（并在此时停止）。

• 源字符串必须以 '\0' 结束。
• 会将源字符串中的 '\0' 拷贝到目标空间。
• 目标空间必须足够大，以确保能存放源字符串。
• 目标空间必须可变。(不加const修饰)

我们来看一段代码：

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

结果如图所示：

可以看到，第一次打印和第二次打印的结果是相同的，而且arr1数组中的x全部被覆盖了，为什么呢？

首先，我们知道strcpy的功能是将第二个参数中的内容传递给第一个参数，返回类型是char*，这样设计的同时让strcpy能够进行函数的链式访问。arr1中的内容全部被覆盖的原因是strcpy运行时，将第arr2中的'\0'也传递到了arr1中。我们可以通过调试窗口观察到：

我们在上面说过strcpy拷贝时目标空间必须可变，如图：

可以看到，我们这样操作程序挂了。

我们可以来模拟实现一下这个函数：

char* my_strcpy(char* destination, const char* source)
{
	assert(destination && source);//断言两个字符串都不为空指针
	char* string = destination;//这里需要提前存一下destination刚开始时的地址,因为后面destination的地址会发生偏移
	while (*destination && *source)
	{
		*destination = *source;
		destination++;
		source++;
	}
	//这里循环到了'\0'就不进入循环体内部了,所以\0并没有被赋值到destibatione中,需要我们手动赋值
	*destination = *source;
	return string;//返回起始位置的地址
}

int main()
{
	char arr1[20] = "xxxxxxxxxxxxxxxx";//这里表示的是用指针指向一个常量字符串,该字符串不可被修改
	char arr2[] = "hello world";
	printf("%s\n", my_strcpy(arr1, arr2));
	printf("%s\n", arr1);
	return 0;
}

当然我们可以把my_strcpy进行一下简化：

char* my_strcpy(char* destination, const char* source)
{
	assert(destination && source);//断言两个字符串都不为空指针
	char* string = destination;//这里需要提前存一下destination刚开始时的地址,因为后面destination的地址会发生偏移
	while (*destination++ = *source++);
	//这里随着*source最后的'\0'赋值给*destination,循环终止
	return string;//返回起始位置的地址
}

这个函数也是非常灵活的，我们不一定要让目标字符串中的全部内容都被源字符串覆盖，也不一定让源字符串全部覆盖过去：

2.2 strcat

函数strcat的返回类型和参数如下：

char * strcat ( char * destination, const char * source );

• Appends a copy of the source string to the destination string. The terminating null character in destination is overwritten by the first character of source, and a null-character is included at the end of the new string formed by the concatenation of both in destination. — 译：将源字符串的副本附加到目标字符串中。目标中的终止空字符将被源的第一个字符覆盖，并且在目标中两者的连接形成的新字符串的末尾包含一个空字符。
• 源字符串必须以 '\0' 结束。
• 目标空间必须有足够的大，能容纳下源字符串的内容。
• 目标空间必须可修改。

我们来展示一下：

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

运行结果如图所示：

可以看到，第一次打印和第二次打印的结果是相同的，因为strcat函数的返回类型也是char*，并且strcat的功能是把源字符串追加到目标字符串的后面。

我们可以来模拟实现一下：

#include <stdio.h>
#include <assert.h>
char* my_strcat(char* destination, const char* source)
{
	assert(destination && source);
	char* string = destination;
	//找到第目标字符串处的'\0'
	while (*destination++);//此处找到的是'\0'后面一位的地址
	char* dest = destination - 1;//确定'\0'的位置
	while (*dest++ = *source++);
	return string;
}

int main()
{
	char arr1[20] = "hello ";
	char arr2[] = "world";
	printf("%s\n", my_strcat(arr1, arr2));
	printf("%s\n", arr1);
	return 0;
}

2.3 strcmp

函数strcmp的返回类型和参数如下：

int strcmp ( const char * str1, const char * str2 );

• This function starts comparing the first character of each string. If they are equal to each other, it continues with the following pairs until the characters differ or until a terminating null-character is reached.  译： 此函数开始比较每个字符串的第一个字符。如果它们彼此相等，则继续使用以下的对，直到字符不同或达到终止的空字符。
• 标准规定：
  • 第一个字符串大于第二个字符串，则返回大于0的数字
  • 第一个字符串等于第二个字符串，则返回0
  • 第一个字符串小于第二个字符串，则返回小于0的数字
    
    这这里可以看到，字符串"abcd"和字符串"abq"相比，字符串"abcd"是小于"abq"的。
    它们比较的逻辑在上面有说到。
    那我们来模拟实现一下这个函数吧：

#include <stdio.h>
#include <assert.h>
int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str1);
	while (*str1 == *str2)
	{
		//两个字符相等才会进入循环,所以在循环里面判断其中一个是否等于'\0',另一个也一定等于'\0'
		if(*str1 == '\0')
		str1++;
		str2++;
	}
	if (*str1 > *str2)
		return 1;
	else
		return -1;
}
int main()
{
	int ret = my_strcmp("abcd", "abq");
	printf("%d\n", ret);
	return 0;
}

在VS这个环境底下，第一个字符大于第二个字符，返回1；第一个字符小于第二个字符，返回-1。
但并不代表所有编译器底下都是这么返回的，标准规定的是：第一个字符大于第二个字符，返回一个大于0的数；第一个字符小于第二个字符返回一个小于0的数。
所以我们也可以这样设计my_strcmp：

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str1);
	while (*str1 == *str2)
	{
		//两个字符相等才会进入循环,所以在循环里面判断其中一个是否等于'\0',另一个也一定等于'\0'
		if (*str1 == '\0')
			str1++;
		str2++;
	}
	return (*str1 - *str2);
}

 
 

3. 长度受限制的字符串函数

---

3.1 strncpy

函数strncpy的返回类型和参数如下：

char * strncpy ( char * destination, const char * source, size_t num );

• Copies the first num characters of source to destination. If the end of the source C string (which is signaled by a null-character) is found before num characters have been copied, destination is padded with zeros until a total of num characters have been written to it. 译： 将源文件的第一个数个字符复制到目标文件。如果在复制num字符之前找到源C字符串的结尾（由空字符表示的信号），则将用零填充目标，直到写入了全部num字符为止。
• 拷贝num个字符从源字符串到目标空间。
• 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

我们可以看到函数strncpy比函数strcpy多出一个参数：size_t num，其他参数都是一样的，这里的size_t num是限制源字符串要拷贝多少个字符到目标字符串中，意思就是假如source有100个字符，而num是5，那么就只拷贝5个字符到destination中。
我们可以测试一下：

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

int main()
{
	char arr1[20] = "abcdefg";
	char arr2[] = "xxxxxxxxxxxxx";
	printf("%s\n", strncpy(arr1, arr2, 5));//这边只拷贝5个字符
	printf("%s\n", arr1);
	return 0;
}

结果如图所示：

我们可以通过调试来看一下：

当我们执行完strncpy以后结果就是这样。

还有一种情形：

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

int main()
{
	char arr1[20] = "abcdefg";
	char arr2[] = "xxx";
	printf("%s\n", strncpy(arr1, arr2, 5));//这边只拷贝5个字符
	printf("%s\n", arr1);
	return 0;
}

运行结果是这样的：

通过调试的角度来看一下：

可以看到当我们要拷贝的个数(num)比源字符串(source)的字符要多时，不够的话会拿'\0'来凑。

我们可以模仿实现一下：

#include <assert.h>
#include <stdio.h>

char* my_strncpy(char* destination, const char* source, size_t num)
{
	assert(destination && source);
	int i = 0;
	char* string = destination;
	while (i < num)
	{
		i++;
		//我们这里这样操作的目的是当我们要拷贝的个数比源字符串的字符要多时，不够的话就拿`'\0'`来凑。
		if (*source != '\0')
		{
			*destination = *source;
			source++;
		}
		else
			*destination = '\0';
		destination++;
	}
	return string;
}

int main()
{
	char arr1[20] = "abcdefg";
	char arr2[] = "xxxxxxxxxxx";
	printf("%s\n", my_strncpy(arr1, arr2, 5));//这边只拷贝5个字符
	printf("%s\n", arr1);
	return 0;
}

调试窗口的角度来看：

但我感觉，如果不用补'\0'的话实现起来会更加方便，也可以实现效果：

char* my_strncpy(char* destination, const char* source, size_t num)
{
	assert(destination && source);
	int i = 0;
	char* string = destination;
	while (i < num)
	{
		i++;
		*destination = *source;
		if (*destination == '\0')
			break;
		source++;
		destination++;
	}
	return string;
}

int main()
{
	char arr1[20] = "abcdefg";
	char arr2[] = "xx";
	printf("%s\n", my_strncpy(arr1, arr2, 5));//这边只拷贝5个字符
	printf("%s\n", arr1);
	return 0;
}

调试角度如图：

3.2 strncat

函数strncat的返回类型和参数如下：

char * strncat ( char * destination, const char * source, size_t num );

• Appends the first num characters of source to destination, plus a terminating null-character. 译： 将源代码的第一个num字符附加到目标代码中，再加上一个终止的空字符。
• If the length of the C string in source is less than num, only the content up to the terminating null-character is copied. 译： 如果源中C字符串的长度小于num，则只复制直到终止空字符的内容。

我们可以看到函数strncat比函数strcat多出一个参数：size_t num，其他参数是一样的，这里的num限制的是在目标字符串追加源字符串的num个字符，如果我们需要追加的个数大于了源字符串的个数，那么追加到源字符串末尾的'\0'就停止了。

这里我们可以测试一下：

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

调试窗口如图所示：

从这里我们不方便看到具体是怎么最佳的，我们可以这样操作来看看追加的方式：

这样我们可以看出，我们想追加再长的字符，也只追加到源字符串末尾的'\0'就停止了。

如果源字符串够长，而我们只追加几个字符的话，又会是怎样呢？

这里我们可以看到，我们追加完3个字符以后，为了保证字符串的完整，后面也加了个'\0'。

我们可以模拟实现一下：

#include <stdio.h>
#include <assert.h>

char* my_strncat(char* destination, const char* source, size_t num)
{
	assert(destination && source);
	int i = 0;
	char* string = destination;
	while (*destination)
		destination++;
	while (i < num)
	{
		i++;
		*destination = *source;
		if (*destination == '\0')
			break;
		destination++;
		source++;
	}
	if (i == num)
		*destination = '\0';
	return string;
}

int main()
{
	char arr1[20] = "abcdefg\0hhhhh";
	char arr2[] = "xxxxxxxxxxxxxxxxxx";
	printf("%s\n", my_strncat(arr1, arr2, 3));
	printf("%s\n", arr1);
	return 0;
}

调试角度如图所示：

3.3 strncmp

函数strncmp的返回类型和参数如下：

int strncmp ( const char * str1, const char * str2, size_t num );

• 比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。
  
  我们可以看到函数strncmp比函数strcmp多出一个参数：size_t num，其他参数是一样的，这里的num限制的是比较两个字符串的前num个字符。

我们举个例子：

这里可以看到，我们只比较前3个字符，而这两个字符串的前三个都是一样的，所以返回 0 。
比较前4个以上，都会返回-1，如图：

我们可以模拟实现一下：

#include <stdio.h>
#include <assert.h>

int my_strncmp(const char* str1, const char* str2, size_t num)
{
	assert(str1 && str2);
	int i = 0;
	while (i < num)
	{
		i++;
		if (*str1 == NULL || *str2 == NULL )
			break;
		else if (*str1 != *str2)
			break;
		str1++;
		str2++;
	}
	if (*str1 - *str2 > 0)
		return 1;
	else if (*str1 - *str2 < 0)
		return -1;
	else
		return 0;
}

int main()
{
	char arr1[] = "abcdefg";
	char arr2[] = "abcd";
	printf("%d\n", my_strncmp(arr1, arr2, 7));
	return 0;
}

 
 

4. 字符串查找

---

4.1 strstr

函数strstr的返回类型与参数如下：

char * strstr ( const char *str1, const char * str2);

• Returns a pointer to the first occurrence of str2 in str1, or a null pointer if str2 is not part of
  str1. 译： 返回一个指向str1中第一次出现的str2的指针，或者如果str2不是str1的一部分，则返回一个空指针。

举个例子：

我们可以看到如果arr1中没有arr2就会返回的一个空指针，所以在使用时会有一定的风险，我们应该这样：

 

我们可以模拟实现一下这个函数：

#include <stdio.h>
#include <assert.h>

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	char* cp = str1;
	char* s1 = cp;
	char* s2 = str2;
	while (*cp != '\0')
	{
		s1 = cp;
		s2 = str2;
		while (*s1 == *s2 && *s1 != '\0' && *s2 != '\0')
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
			return cp;
		cp++;
	}
	return NULL;
}


int main()
{
	char arr1[] = "abbbcdef";
	char arr2[] = "bbc";
	char* ret = my_strstr(arr1, arr2);
	if (ret != NULL)
		printf("%s\n", ret);
	else
		printf("找不到\n");
	return 0;
}

4.2 strtok

函数strtok的返回类型和参数如下：

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

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

说了那么多，让我们来看一下这个函数是怎么用的吧：

我们假设要分割一个邮箱，看看邮箱由那些元素组成，我们把邮箱单独存入到一个字符串中，然后把邮箱中的分隔符拿出来单独做一个字符串。
注： 当我们strtok函数时，因为该函数会对字符串进行修改，所以建议在使用该函数时，先将想分割的字符串进行拷贝。如图：

第一个参数我们先传入字符串copy，第二个参数我们传入分隔符字符串delimiters。这个函数会将字符串copy中含有分隔符的地方转换成'\0'，并保存它在字符串中的位置，再返回一个指向这个标记的指针。如图：

当strtok函数的第一个参数为 NULL时 ，函数将在同一个字符串中被保存的位置（也就是我们第一次将@修改成'\0'的地方）开始，查找下一个标记。如图：

这样就分割完成了。当然，如果我们再第一次就讲NULL传入到第一个参数中，程序就会异常退出：

当我们已经分割完成以后，如果字符串中不存在更多的标记，则返回 NULL 指针。上所以面这部分的分割，我们也可以直接用一个循环表示出来：

4.3 atoi

函数atoi的返回类型和参数如下：

头文件:<stdlib.h>
int atoi (const char * str);

• 会将一个数字字符串转换为数组返回过来。（如：将字符串"-123"转换成123）
• 遇到空白字符（空白字符：空格‘ ’，换页‘\f’，换行’\n’，回车‘\r’，制表符’\t’或者垂直制表符’\v’）会自动跳过。
• 遇到非数字字符会将非数字字符之前出现的数字字符转换成数字返回过来，如果非数字字符前面没有就返回0。

我们先举个🌰看看这个函数的用法：

我们可以来模拟实现一下这个函数：

#include <stdio.h> /*printf gets*/
#include <ctype.h> /*isspace isdigit*/
#include <limits.h> /*INT_MIN INT_MAX*/ //这两个函数下面的章节会讲到
#include <assert.h> /*assert*/
//要实现这个函数。我们需要考虑一下问题：
//1. 空指针
//2. 空字符串
//3. 空白字符串
//4. 数字超出范围


//因为这里的异常情况较多,所以我们定义一个枚举常量来看是否合法
enum State
{
	VALID, //合法
	INVALID //异常
}state = INVALID;//全局的状态,它的值标志返回的是合法还是异常的值

int my_atoi(char* str)
{
	assert(str);
	int flag = 1;
	if (*str == '\0')//空字符串
	{
		state = INVALID;
		return 0;
	}
	//跳过空白字符
	while (isspace(*str))
	{
		str++;
	}
	//处理正负号的问题
	if (*str == '-')
	{
		flag = -1;
		str++;
	}
	else if (*str == '+')
	{
		str++;
	}
	long long ret = 0;
	while (*str != '\0')
	{
		if (isdigit(*str))
		{
			ret = ret * 10 + flag * (*str - '0');
			if (ret < INT_MIN || ret > INT_MAX)
			{
				state = INVALID;
				return 0;
			}
		}
		else
		{
			state = INVALID;
			return ret;
		}
		str++;
	}
		state = VALID;//正常转换
		return (int)ret;
}

int main()
{
	char str[256];
	while (gets(str) != EOF)
	{
		my_atoi(str);//这里要先使用该函数来确定一下state的值,因为state的值是在函数my_atoi中发生变化的
		if (state == VALID)
		{
			printf("%d\n", my_atoi(str));
		}
		else
		{
			printf("非法返回:%d\n", my_atoi(str));
		}
	}
	return 0;
}

效果如图所示：

 
 

5. 错误信息报告

---

5.1 strerror

函数strerror的返回类型和参数如下：

char * strerror ( int errnum );

• 返回错误码所对应的错误信息

errno是C语言提供的全局变量，库函数在执行的时候发生了错误，会将一个错误码存放在errno这个变量中。每个错误信息的错误码都互不相同

这里我们来看部分错误码所代表的意思：

我们在使用该函数时，正确的用法是在使用库函数时，可能会出现错误的地方下面及时使用strerror(error)，因为在使用过程中，如果在可能出错的地方不及时查看错误信息时，在后面其他地方使用库函数出错，错误码error就会跟着改变，就看不到原来的错误信息了。
举个例子：

5.2 perror

这里相比之下，有一个函数更加方便：perror，返回类型和参数如下：

void perror ( const char * str );

这个函数可以直接打印出来错误信息，如图：

可以看到，perror也能够完成strerror的作用。而且相比之下，perror还是要比strerror方便一些。

 
 

6. 字符操作函数

---

6.1 字符分类函数

函数<ctype.h>	如果它的参数符合下列条件就返回真
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	任何可打印字符，包括图形字符和空白字符

6.2 字符转换函数

//头文件：<ctype.h>
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 = 0;
	while (str[i])
	{
		c = str[i];
		if (isupper(c))
		{
			c = tolower(c);
		}
		putchar(c);
		i++;
	}
	return 0;
}

结果如图所示：

 
 

7. 内存操作函数

---

7.1 memcpy

函数memcpy的返回类型和参数如下：

void * memcpy ( void * destination, const void * source, size_t num );

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

我们来举个🌰演示一下这个函数怎么用吧：

从这个🌰中可以看出来，函数memcpy是可以拷贝任意类型的，因为它拷贝的是内存中存储的数据，在这几我们介绍的三个函数都是对内存中的数据进行操作。

我们可以模仿实现一下这个函数：

#include <stdio.h>
#include <assert.h>

void* my_memcpy(void* destination, void* source, size_t num)
{
	assert(destination && source);
	void* ret = destination;
	while (num--)
	{
		*(char*)destination = *(char*)source;
		//注：这里不能直接写成(char*)desination++,自增操作符的优先级比强制类型转换要高
		destination = (char*)destination + 1;//强制类型转换只是临时的转换
		source = (char*)source + 1;
	}
	return ret;
}


int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	my_memcpy(arr2, arr1, 20);
	int i = 0;
	for (i = 0;i < 20;i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

效果如图：

假设我们写成这样的形式：

我们这样拷贝，想的是将arr1中的前五个元素拷贝到arr1[3]的后面，预期输出结果：1 2 1 2 3 4 5 8 9 10（红色的是我们认为拷贝进去的）。

但实际输出结果如图：

这里输出这中结果的原因是，我们上传到my_memcpy的是同一片空间的内容，然后拷贝$20$个字节，也就是要拷贝覆盖$5$个整型元素。

所以就导致出现这样的结果。

📖：在这里强调一下，memcpy是用来处理两个未重叠的数组的，不建议使用来处理两个重叠的数组。

那如果我们想处理两个重叠的数组，应该怎么处理呢？

7.2 memmove

函数memmove的返回类型和参数如下：

void * memmove ( void * destination, const void * source, size_t num );

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

用这个函数来测试我们之前那个🌰：

这样就可以得到我们之前想要的结果了。

我们可以来模拟实现一下这个函数：

思路1：

但这个思路实现起来过于繁琐。我们来看一下另一个思路。
 
思路二：

我们来按照这个思路来实现一下吧：

#include <stdio.h>
#include <assert.h>

void* my_memmove(void* destination, const void* source, size_t num)
{
	assert(destination && source);
	void* ret = destination;
	if (destination > source)
	{
		int i = num;
		while (i--)
		{
			*((char*)destination + i) = *((char*)source + i);
		}
	}
	else
	{
		int i = 0;
		while (i < num)
		{
			*((char*)destination + i) = *((char*)source + i);
			i++;
		}
	}
	return ret;
}

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	my_memmove(arr1 + 2, arr1, 20);
	int i = 0;
	for (i = 0;i < 20;i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

结果如图：

7.3 memset

函数memset的返回类型和参数如下：

void * memset ( void * ptr, int value, size_t num );

• 把ptr指向的空间内存的前num个字节的内容设置成一个指定的value值

我们举个🌰看看它的用法：

⭐️ ：需要注意的是，这个函数是以字节为单位来设置的。也就是说我们只能用这个函数将一个数组设置成全0，如图：

设置前：

设置后：

也就意味着，如果我们初始化为其他数，就会产生这样的效果：

7.4 memcmp

函数memcmp的返回类型和参数如下：

int memcmp ( const void * ptr1, const void * ptr2, size_t num );

• 比较从ptr1和ptr2指针开始的num个字节
• 返回值如下：
  

这个函数的功能就是比较前num个字节是否相等：$ptr1>ptr2$返回大于0的数，$ptr1=ptr2$返回0，$ptr1<ptr2$返回小于0的数。