一、memcpy函数的使用和模拟实现

（一）memcpy函数的使用

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

1.函数memcpy从source的位置开始向后复制num个字节的数据到destination指向的内存的位置；

2.这个函数在遇到'\0'的时候并不会停下来；

3.如果source和destination有任何的重叠，复制的结果都适合未定义的。

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

（二）memcpy函数的模拟实现

#include<assert.h>

void* my_memcpy(void* dst, const void* src, size_t num)
{
	void* ret = dst;
	assert(dst && src);
	while (num--)
	{
		*(char*)dst = *(char*)src;
		dst = (char*)dst + 1;
		src = (char*)src + 1;
	}
	return ret;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0 };
	my_memcpy(arr2, arr1, 20);
	for (int i = 0; i < 10; i++)
	{
		printf("%2d", arr2[i]);
	}
	return 0;
}

接下来，我们来探讨一下“source和destination有任何的重叠，复制的结果都适合未定义的。”这种问题：

#include<assert.h>

void* my_memcpy(void* dst, const void* src, size_t num)
{
	void* ret = dst;
	assert(dst && src);
	while (num--)
	{
		*(char*)dst = *(char*)src;
		dst = (char*)dst + 1;
		src = (char*)src + 1;
	}
	return ret;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0 };
	my_memcpy((arr1)+2, arr1, 20);
	for (int i = 0; i < 10; i++)
	{
		printf(" %d", arr1[i]);
	}
	return 0;
}

这里我们可以看出，我们自己模拟实现的my_memcpy函数并不能实现重叠空间的正常拷贝，原因是当我们拷贝完第一个1,2时，原来3,4的位置就已经变为了1,2，所以以后拷贝的就全部都是1,2。

然而，当我们用C语言库中的memcpy函数时，

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

虽然这里是正确的，但是我们必须要强调，有重叠部分的拷贝时，不要用memcpy，我们应该交给memmove来处理。

二、memmove函数的使用和模拟实现

（一）memmove函数的使用

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

1memmove与memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的；

2.如果源空间和目标空间出现重叠，就得使用memmove函数处理。

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

（二）memmove函数的模拟实现

模拟实现memmove我们有一个关键点需要解决，那就是如何解决内存重叠的问题？

当目标内存在源内存后面，且二者有重叠部分时，一旦我们从前向后赋值，必然会导致一部分源内存被修改。但是，如果我们采用从后向前赋值呢？

我们会惊奇的发现，竟然是可行的。那么我们又会思考是不是每一个情况都可以用从后向前来解决？其实并不是。

当目标内存在源内存前面，且二者有重叠部分时，一旦我们从后向前赋值，必然也会导致一部分源内存被修改。

所以，此时我们就应该分类讨论了，一种比较简单的分类情况是：

1.当目标内存在源内存前面，且二者有重叠部分时，我们采用从前向后赋值；

2.其余情况我们一律采用从后向前赋值。

所以我们就可以来模拟实现memmove函数：

void* my_memmove(void* dst, const void* src, size_t num)
{
	void *ret= dst;
	if (dst < src)
	{
		while (num--)
		{
			*((char*)dst) = *((char*)src);
			dst = (char*)dst + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		while (num--)
		{
			*((char*)dst+num) = *((char*)src+num);
		}
	}
	return ret;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0 };
	my_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);

memset使用来设置内存的，将内存中的值以字节为单位设置成想要的内容。

int main()
{
	char str[] = "hello world.";
	memset(str, 'x', 6);
	printf("%s", str);
	return 0;
}

四、memcmp函数的使用

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

比较从ptr1和ptr2指针指向的位置开始，向后num个字节。

返回值如下：

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8 };
	int arr2[] = { 1,2,3,4,9,9,9,9 };
	int ret = memcmp(arr1, arr2, 16);
	printf("%d", ret);
}

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8 };
	int arr2[] = { 1,2,3,4,9,9,9,9 };
	int ret = memcmp(arr1, arr2, 20);
	printf("%d", ret);
}