memcpy()、memmove()函数的模拟实现———C语言

很为这个函数很容易考，且很容易出错！！！

memcpy()

函数原型： void * memcpy（void * destination，const void * source，size_t num）

函数功能:将source指向的内存空间的num个字节值直接复制到destination指向的内存空间。

参数：source原内容内存的起始地址，destiantion目标地址的起始地址

返回值：目标destination的起始地址

注意：

1. 内存空间不能重叠（这是对同一个内存块进行操作的情况，如果不是同一个内存块可以不考虑）
2. memcpy（）函数是内存操作函数，对与复制的内容没有要求适用范围较广
3. memcpy（）是将 num个字节， 虽然memcpy（）对复制的内容完全没有任何的限制，比如数组，结构体等特殊的结构，如果你想将整个结构体变量的内容复制到destination内存区，最好使用sizeof将要复制的内容的完整大小求出来赋值给num，以保持复制的完整性

实现思想: 首先memcpy（）类似字符串拷贝函数strncpy（）只是一个只能用于字符串拷贝，而另一个范围较广。我们可以参照strncpy（）的实现方式来实现，还要注意就是memcpy（）不考虑’\0’而字符串操作函数都是以’\0’为结束条件的

void* my_memcpy(void* dst, const void* src, size_t num)
{
	assert(dst && src);//判断输入不能是空
	
	//进行强制类型转换 void*不能进行解引用和进行++或--
	char* dst_ = (char*)dst;
	const char* src_ = (const char*)src;
	
	while (num--)
	{
		*dst_ ++= *src_++;
    }
	return dst;
}

memmove()

函数原型： void *void * memmove（void * destination，const void * source，size_t num）

函数功能:memmove（）用于从source拷贝num个字节到destination，如果目标区域和源区域有重叠的话，memmove（）能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中。但复制后source内容会被更改。

参数：source原内容内存的起始地址，destiantion目标地址的起始地址

返回值：目标destination的起始地址

注意：

1. 内存空间可以重叠，也可以不重叠（这就相当于memcpy（）的升级优化）
2. memmove（）函数是内存操作函数，对与复制的内容没有要求适用范围较广
3. memmove（）是将 n个字节， 虽然memmove（）对复制的内容完全没有任何的限制，比如数组，结构体等特殊的结构，如果你想将整个结构体变量的内容复制到destination内存区，最好使用sizeof将要复制的内容的完整大小求出来赋值给num，以保持复制的完整性

实现思想: 首先memove（）类似字符串拷贝函数memcpy（）就相当于在memcpy（）的基础上考虑一下内存重叠的问题，在写函数的时候可以把void*进行类型转换方便操作，看图大概就是三种情况：

void* my_memmove(void* dst, const void* src, size_t num)//考虑内存重叠
{
	assert(dst && src);//判断输入的是否为空
	
    //进行强制类型转换 void*不能进行解引用和进行++或--
	char* dst_ = (char*)dst;
	const char* src_ = (const char*)src;
	char* ret = (char*)dst;

	if (dst_ > src_ && dst_ < src_ + num)//内存重叠
	{
		while (num--)
		{
			*(dst_ + num) = *(src_ + num);
		}
	}
	else//内存不重叠
	{
		while (num--)
		{
			*dst_++ = *src_++;
		}
	}
	return ret;
}

总代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include
#include
void* my_memcpy(void* dst, const void* src, size_t num)
{
	assert(dst && src);

	//进行强制类型转换 void*不能进行解引用和进行++或--
	char* dst_ = (char*)dst;
	const char* src_ = (const char*)src;
	char* ret = (char*)dst;

	while (num--)
	{
		*dst_ = *src_;
		++dst_;
		++src_;
	}
	return ret;
}

void* my_memmove(void* dst, const void* src, size_t num)//考虑内存重叠
{
	assert(dst && src);

	char* dst_ = (char*)dst;
	const char* src_ = (const char*)src;
	//char* ret = (char*)dst;

	if (dst_ > src_ && dst_ < src_ + num)//内存重叠
	{
		while (num--)
		{
			*(dst_ + num) = *(src_ + num);
		}
	}
	else
	{
		while (num--)
		{
			*dst_++ = *src_++;
		}
	}
	return dst;
}

int main()
{
	char str[] = "memmove can be very useful......";
	char arr2[20] = { "hello " };
	char arr3[] = { "world" };
	my_memcpy(arr2 + 5, arr3, sizeof(arr3));
	my_memmove(str + 20, str + 15, 11);
	puts(arr2);
	puts(str);
	system("pause");
	return 0;
}

运行截图：