模拟实现memcpy和memmove

C语言：模拟实现memcpy和memmove

模拟实现strlen：https://blog.csdn.net/weixin_44304853/article/details/102648277
模拟实现strcpy：https://blog.csdn.net/weixin_44304853/article/details/102648413
模拟实现strlcat：https://blog.csdn.net/weixin_44304853/article/details/102648518
模拟实现strcmp：https://blog.csdn.net/weixin_44304853/article/details/102648662
模拟实现strstr：https://blog.csdn.net/weixin_44304853/article/details/102648736

1.memcpy：内存拷贝函数

• 函数原型：void *memcpy(void *dst, void src, size_t count);
• 参 数：
  dst-- 指向用于存储复制内容的目标数组，类型强制转换为 void* 指针。
  src-- 指向要复制的数据源，类型强制转换为 void* 指针。
  count-- 要被复制的字节数。
• 返 回 值：该函数返回一个指向目标存储区dst的指针。
• 功 能：从源src所指的内存地址的起始位置开始拷贝n个字节到目标dst所指的内存地址的起始位置中。
• 所需头文件：C语言：#include<string.h>；C++：#include

memcpy函数的模拟实现：

#include<stdio.h>
#include<assert.h>
#include<string.h>
void * my_memcpy(void * dst, const void * src, size_t count)
{
	assert(dst&&src);
	while (count--)
	{
		*(char *)dst = *(char *)src;
		dst = (char *)dst+1;
		src = (char *)src + 1;
	}
	return dst;
}
struct
{
	char name[20];
	int age;
}person, person_copy;
int main()
{
	char myname[] = "abcdefgh";
	//using memcpy to copy string
	my_memcpy(person.name, myname, strlen(myname) + 1);
	person.age = 46;

	//using memcpy to copy structure
	my_memcpy(&person_copy, &person, sizeof(person));
	printf("person_copy:%s,%d", person_copy.name, person_copy.age);
	return 0;
}
int main()
{
	char str[] = "memmove an be very usefull";
	my_memmove(str + 20, str + 15, 11);
	printf("%s\n", str);
	return 0;
}

2.memmove：内存移动函数

• 函数原型：void memmove( void dst, const void* src, size_t count );
• 参 数：
  dst-- 指向用于存储复制内容的目标数组，类型强制转换为 void* 指针。
  src-- 指向要复制的数据源，类型强制转换为 void* 指针。
  count-- 要被复制的字节数。
• 返 回 值：该函数返回一个指向目标存储区dst的指针。
• 功 能：从源src所指的内存地址的起始位置开始拷贝n个字节到目标dst所指的内存地址的起始位置中。
• 所需头文件：C语言：#include<string.h>；C++：#include

memmove函数的模拟实现：

#include<stdio.h>
#include<assert.h>
#include<string.h>
void * my_memmove(void * dst, const void * src, size_t count)
{
	assert(dst&&src);
	if (dst < src || (char *)dst >= ((char *)src + count))
	{
		while (count--)
		{
			*(char *)dst = *(char *)src;
			dst = (char *)dst + 1;
			src = (char *)src + 1;
		}
	}
	else 
	{
		dst = (char *)dst + count-1;
		src = (char *)src + count-1;
		while (count--)
		{
			*(char *)dst = *(char *)src;
			dst = (char *)dst -1;
			src = (char *)src -1;
		}
	}
}

注意：可以看到，memcpy和memmove功能基本一样，但如果目标区域和源区域有重叠的话，memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中，但复制后源内容会被更改。但是当目标区域与源区域没有重叠则和memcpy函数功能相同。

3.memcpy的局限性：

举个例子：给一个数组arr[9] = {1，2，3，4，5，6，7，8，9}；

现在需要将 1，2，3，4，5拷贝到 5， 6， 7， 8，9这几个数的位置去。如果你正序拷贝，你会发现将1拷到5的位置，2拷到6的位置，3拷到7的位置，4拷到8的位置，但是你再继续将5拷贝到9的位置的时候，你会发现5已经被改成了1，你再也无法将5拷贝到9的位置了。

代码演示：

int main()
{
	int arr[9] = {1,2,3,4,5,6,7,8,9};
	my_memcpy(arr + 4,arr,sizeof(int)*5);
	for (int i = 0; i < 9; i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n ");
}

所以，你需要进行反向拷贝，就是从5开始向前拷贝，先将5拷到9的位置，再将4拷到8的位置，再将3拷到7的位置，再将2拷到6的位置，再将1拷到5的位置，这样就不会遇到无法完全拷贝的问题。
代码演示：

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

• 什么时候需要反向拷贝。
  每当有你需要拷贝的数据的起始位置将要拷贝到你需要拷贝的位置发生了冲突，也就是将要被拷贝到的位置比将要拷贝数字的位置大，这样你就可以反向拷贝了。
  反向拷贝条件：dst < src || (char *)dst >= ((char *)src + count)