常见内存函数的模拟实现

memcpy

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

（2）这个函数会在遇到 ‘\0’ 的时候不会停下来

（3）如果source和destination有任何重叠，复制结果都是未定义的

void* my_memcpy(void* dest, const void* src, size_t sz)
{
	assert(dest && src);
	while (sz--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest +1;
		src = (char*)src + 1;
	}
}

int main()
{
	int arr1[10] = { 0 };
	int arr2[] = { 1,2,3,4,5 };
	//把arr2中的前5个整数的数据，拷贝放在arr1中
	my_memcpy(arr1, arr2, 20);

	return 0;
}

同strcpy不同，memcpy可以接收任何类型的数据

那么这么有趣的函数如何实现呢

void* my_memcpy(void* dest, const void* src, size_t sz)
{
	assert(dest && src);
	while (sz--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
}

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memcpy(arr+2,arr,20);
	return 0;
}

我在测试的时候用的数据拷贝到自身的情况，正常来说memcpy拷贝重叠数组的效率为60%，但测试环境为vs2022,效率为100%，属于是超额完成任务了

memmove

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

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

由于和memcpy类似就不做使用示范

有趣的是该函数的模拟实现

第一种方法就是创造两个数组一一拷贝过去即可，但是这种方法过于繁琐

那么我们就创建一个数组

情况（1）将源数组1，2，3，4，5拷贝到目标3，4，5，6，7处，这时我们不能从前向后拷贝，因为会覆盖掉源数组里面的数据，那么只能从后向前拷贝

情况（2）这次是将源数组5，6，7，8，9拷贝到目标3，4，5，6，7处，然而却不能再从后向前拷贝，同样会出现覆盖源数组的情况，只能从前向后拷贝

这时我就会发现其实是有‘临界点’，通过临界点判断到底是从后向前还是从前向后，当源数组没有坐落与目标任何一边的‘临界点’时，且没有发生越界怎么拷贝都是可行的

void* my_memmove(void* dest, const void* src, size_t sz)
{
	assert(dest && src);
	void* ret = dest;
	if (dest < src)
	{
		//前->后
		for (int i = 0; i < sz; i++)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		//后->前
		while (sz--)
		{
			*((char*)dest+sz) = *((char*)src + sz);
			//为找到数据的开始位置将其进行强转并加上sz再解引用
		}
	}
	return ret;
}

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

	return 0;
}