#include<stdio.h>
#include<assert.h>
void * my_memcpy(void* des,const void * sor, size_t num)
{
	assert(des && sor);
    void* ret = des;
	size_t i = 0;
	while ( num-- )
	{
		*(char*)des = *(char *)sor;
		(char *)des = (char*)des+1;
		(char *)sor = (char*)sor+1;
	}
	return ret;
}
int main()
{
	int arr1[] = {1,2,3,4,5,6};
	int arr2[20] = { 0 };
	int sz = sizeof(arr1) / sizeof(arr1[0]);
	my_memcpy(arr2,arr1,sz*sizeof(int));
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		printf("%d",arr2[i]);
	}
	return 0;
}

首先，我们需要注意的是，最后一个参数的计算，因为我们是以1字节为单位进行计算的，所以我们用sizeof函数计算原数据类型的大小，然后乘以原数据类型的打算拷贝的个数，即可得memcpy函数需要用到的个数。

然后在函数具体实现时，我们采用while循环，相对于for循环来说，相对简洁。然后在赋值以及移位时，千万不能丢的是强制类型转换。如果没有转换，函数在实现的的时候是出错的。

最后，当然不能丢的是断言，来检查参数是否有效，然后再做其他步骤。?

二，memmove“有重叠”内存拷贝函数

2.1memcpy函数和memmove函数的区别。

2.1.1?由来

通过标题我们知道，memmove也是一个内存拷贝函数，但是该函数是一个有重叠内存拷贝函数，那么为什么这么说呢？如下图所示：

如图所示，有一数组arr，现在我们打算将其 1234，这四个数拷贝到 3456?这四个数的位置上。des为目标指针，sor为源指针。那么我们发现，如果用memcpy的模拟函数拷贝时，当 1 2 拷贝过去之后，3 4 位置的数变为 1 2 ，那么后面 5 6 位置原先应该是 3 4 ，结果拷贝成为?1 2，这种情况我们将其成为“重叠拷贝”。?

2.1.2?区分

?而当我们在一些编译器里面，用库函数memcpy去实现的时候，发现是可以拷贝成功的，也就是说3 4 5 6的位置上面最后是 1 2 3 4。但是C语言标着规定，memcpy函数只需要实现“不重叠”即可，也就是说，源指针和目标指针指向的空间不发生重叠，比如上面，我们将 1 2 3 4，拷贝到 5 6 7 8的位置上，或者在两个数组之间进行拷贝等。

2.1.3模拟实现

因为该函数既要拷贝“重叠”的内存，又要拷贝不重叠的内容。所以如下所示，分两种情况拷贝：

#include<stdio.h>
#include<assert.h>
void* my_memmove(void* des, void* sor, size_t num)
{
	void* ret = des;
	assert(des && sor);
	if (des < sor)
	{
		while (num--)
		{
			*(char*)des = *(char*)sor;
			des = (char*)des + 1;
			sor = (char*)sor + 1;
		}
	}
	else
	{
		while (num--)
		{
			*((char*)des + num) = *((char*)sor+ num);
		}
	}
	return ret;
}
int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	//my_memmove(arr+2 ,arr,4*sizeof(int));
	my_memmove(arr, arr+2, 4 * sizeof(int));
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d",arr[i]);
	}
	return 0;
}

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 情况一

首先，我们知道大概内容与memcpy函数是没有区别的。所以这里我们只分析不一样的地方，那么首先我们分析下图所示的情况，源指针在前，目标指针在后，而且拷贝的内容发生重叠的情况。此时，我们发现，从前往后拷贝是不行的，但是从后往前拷贝，即先从源指针的高地址往低地址处依次拷贝。这样是完全可行的。