C语言：内存操作函数memcpy、memmove、memset和memcpy的使用和模拟实现

一：memcpy的使用和模拟

memcpy使用时需要包含的头文件为#include<string.h>

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

函数memcpy从source的位置开始向后复制num个字节的数据到destination指向的内存位置（特别注意的是这里拷贝的单位是字节）
这个函数在遇到 ‘\0’ 的时候并不会停下来
如果source和destination有任何的重叠，拷贝的结果都是不可预知的

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };

	//将arr1数组中前5个元素(20个字节)的内容拷贝放置在arr2数组中
	memcpy(arr2, arr1, 20);
	for (int i = 0; i < 20; i++)
	{
		printf("%d ", arr2[i]);

	}
	return 0;
}

运行结果：

代码解析：

这个代码的主要作用是将数组arr1中前5个元素（一个int 即4个字节，所以5个元素相当于20个字节）拷贝到数组arr2中，然后我们用一个for循环将数组arr2中的20个元素进行打印

二：memcpy函数的模拟实现

//memcpy拷贝结束后返回目标空间的起始地址
//memcpy的模拟实现
void* my_memcpy(void* dest, void* src, size_t num)
{
	assert(src && dest);
	void* ret = dest;
	while (num--)
	{
		*((char*)dest) = *((char*)src);
		((char*)dest)++;
		((char*)src)++;
	}
	return ret;

}


int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
    //将数组arr1中的前5个元素拷贝至arr2中
    //1  2  3  4  5

	int arr2[20] = { 0 };
    //1 2 3 4 5 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
	my_memcpy(arr2, arr1, 20);

	int i = 0;
	//将数组arr2中的元素打印
	for (i = 0; i < 20; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

代码结果：

代码讲解：

模拟实现memcpy，memcpy拷贝结束后会返回目标空间的起始地址
定义两个指针和两个数组，将源头数组中4个元素（即20个字节）的内容拷贝至目标空间dest数组中，由于我们这里的memcpy函数针对的是内存块，所以memcpy不仅可以实现对int类型数据的拷贝，还可以拷贝char类型的数据。因此我们在这里定义的指针类型为void类型，返回类型为void类型的指针（void类型指针可以接受各种类型的指针类型），但需要注意我们不能直接对void类型的指针实现解引用。

需要注意不能直接src++或者dest++来达到指针向后移动的功能，我们需要将src和dest强制类型转换为具体类型例如char，int类型，但是由于我们是一个字节一个字节的将数组arr1中的前5个数据内容拷贝至arr2中的，如果我们选择强制类型转换成int类型有一些情况下我们可能无法使用。例如如果我们只需要将arr1中的17个字节的内容拷贝至目标空间arr2中的时候如果我们使用强制转换成int类型就无法实现。所以我们需要强制转换成char类型，即 ((*char) src)++和 ((*char) dest)++

由于源头内存不能被修改，所以可以在src前面加上const修饰

另外特别需要注意的是：
由于memcpy函数调用结束后会返回目标空间的起始地址，即指针dest，但是dest在代码中会别使用起始地址已经发生改变，所以一开始的时候我们可以先定义一个指针变量来存放dest的起始地址

小比较：memcpy函数主要考虑的是将一个数组中的元素拷贝至另一个数组中，如果将一个数组中的内容拷贝至同一个数组中拷贝的结果是未知的。例如：将arr1数组中1 2 3 4 5 拷贝至3 4 5 6 7 的位置，由于拷贝的内存空间发生重叠，此时应当使用memmove函数来实现。

三：memmove的使用

void* memmove(void* dest,void* src,size_t num)

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

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

运行结果：

四：memmove函数的模拟实现

情况1：将数组arr1中的数据1 2 3 4 5 拷贝至数组arr + 2（即数据3的位置）的位置，即将数组arr1中的数据3 4 5 6 7 改成1 2 3 4 5 ，需要从后向前拷贝数组arr1的数据，即先将数据5拷贝至7的位置，再将数据4拷贝至6的位置，以此类推，最后将数据1拷贝至3的位置。这是因为如果直接将数据1 2 3 4 5拷贝至3 4 5 6 7的位置会导致数据被覆盖，无法实现要求，如下图所示：

正确拷贝方式如下图：

情况2：
将数组arr1中的数据3 4 5 6 7 拷贝至数组arr1中1 2 3 4 5 的位置，即将数组arr1中的数据1 2 3 4 5改成3 4 5 6 7。在这里我们需要从前向后拷贝数组arr1中的数据，即先将数据3拷贝至1的位置，再将数据4拷贝至2的位置以此类推，最后将数据7拷贝至5的位置，那么数组arr1最终会变成3 4 5 6 7 6 7 8 9 10。拷贝过程如下图所示：

运行结果1：

执行结果2：

小总结：

memmove函数拷贝过程共有3中情况：

第一种情况为：dest < src如下图：

在这种情况下：需要将src中的数据从后向前拷贝至目标空间

第二种情况为dest > src如下图：

在这种情况下：需要将src中的数据从前向后拷贝至目标空间

第三种情况为第十二条和src没有重叠空间如下图：

在这种情况下:即可以将src中的数据从前向后拷贝至目标空间，也可以从后向前将数据拷贝至目标空间

为了方便我们将dest< src分成一种情况，dest > src分成一种情况。

模拟代码：


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

void* memmove(void* dest, const void* src, size_t num)
{
	assert(dest && src);
	void* ret = dest;
	if (dest < src)
	{
		//src从前向后拷贝
		while (num--)
		{
			*((char*)dest) = *((char*)src);
			((char*)dest)--;
			((char*)src)++;
		}
	}
	else
	{
		//src从后向前拷贝
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	
	return ret;
}
//memmove的使用
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr1 + 2, arr1, 20);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

五：memset函数的使用

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

注释：ptr指的是指向要被修改的指针，value指的是要被修改成的内容，num指的是要被修改的个数。

注意：memset是用来设置内存的，将内存中的值以字节为单位设置成想要的内容，以字节为单位就代表着如果我们要修改的内容为int类型可能结果与我们预想的不一样，如下例代码：

#include<stdio.h>
#include<string.h>
//memset的使用
int main()
{
	int arr1[5] = { 1,2,3,4,5 };
	memset(arr1, 1, 20);//以字节为单位将arr1中的5个元素该成1
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

运行结果：

内存情况：

由此可知：由于每个字节的是01，所以最后的结果是16843009而不是1。

六：memcpy函数的使用

int memcpy(const void* ptr1,const void* ptr2,size_t num)

功能：

比较从ptr1和ptr2指针指向的位置开始向后的num个字节的内容
返回值如下：

如果ptr1比较的内容 < ptr2比较的内容，返回 <0的数；

如果ptr1比较的内容 = ptr2比较的内容，返回 0 ；

如果ptr1比较的内容 > ptr2比较的内容，返回 >0 的数；

代码：

#include<stdio.h>
#include<string.h>
//memcpy的使用
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8 };
	int arr2[] = { 1,2,3,4,8,8,8,8 };
	int ret = memcmp(arr1, arr2, 16);//比较arr1和arr2中前16个字节的内容（即4 个元素）
	printf("%d\n", ret);
	return 0;
}

运行结果：

代码：

#include<stdio.h>
#include<string.h>
//memcpy的使用
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8 };
	int arr2[] = { 1,2,3,4,8,8,8,8 };
	int ret = memcmp(arr1, arr2, 20);//比较arr1和arr2中前20个字节的内容（即5个元素）
	printf("%d\n", ret);
	return 0;
}

运行结果：