memcpy函数与memmove函数

1.1

memcpy函数是C语言内存拷贝函数，功能是从原内存地址的起始位置开始依次拷贝若干个字节到从目标地址的起始位置开始依次向后的若干个字节中。

void* memcpy(void* dest,const void* src,size_t num)

void* dest是目标内存 const void* src是源内存 size_t num是拷贝字节个数

返回指向dest的void*指针

1.2

memmove是C语言内存拷贝函数，从源地址向目标地址拷贝若干个字节，如果目标区域与源区域相重叠，memmove能够保证源地址在被覆盖之前正确将重叠区域的字节拷贝到目标区域中。

void* memmove(void* dest,const void* src,size_t count)

void* dest是目标内存，const void* src是源内存，size_t是拷贝字节个数

返回指向dest的void*指针

1.3

memcpy和memmove函数的功能相似，但memcpy要复制的区域不能存在源与目标内存重叠，否则可能导致赋值出错，而memmove函数即使内存重叠赋值仍然正确进行。

1.4

1.3中的两点在我们模拟实现两函数时得到了诠释，然而当我们在不同编译器下使用memcpy函数时有可能内存重叠赋值仍未出错，这可能是由于编译器优化了memcpy函数功能，初学者不必过于纠结。

2.库函数memcpy与memmove:

memcpy:

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

 

由于函数以字节为操作单位且该编译器为小端存储，故数字8被赋值为数字5.

memmove:

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

3.1模拟实现memcpy:

1.内存存在重叠：

#include<stdio.h>
#include<assert.h>
void* my_memcpy(void* dest,const void* src, size_t count)
{
	assert(dest && src);
	char *p=(char*)dest;
	while(count--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest+1;
		src = (char*)src+1;

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

 拷贝出错：

原理：1 2 3 4 5 | 6 7 8 9 10 ->1 2 3 1 2 | 3 7 8 9 10 -> 1 2 3 1 2 | 3 1 2 9 10

内存无重叠：（这里的无重叠是指src+count不小于dest而非没用重叠部分）

#include<stdio.h>
#include<assert.h>
void* my_memcpy(void* dest,const void* src, size_t count)
{
	assert(dest && src);
	char *p=(char*)dest;
	while(count--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest+1;
		src = (char*)src+1;

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

拷贝正确：

3.2模拟实现memmove:

#include<stdio.h>
#include<string.h>
#include<assert.h>

void* my_memmove(void* dest,const void* src, size_t count)
{
	assert(dest && src);
	char * ret = (char*) dest;
	if(dest<src)
	{
		while(count--)
		{
			*(char*)dest = *(char*)(src);
			
		}
	}
	else
	{
		while(count--)
		{
			*((char*)dest+count) = *((char*)src+count);
		}
	}
	return ret;
}
int main()
{
	int arr[10]={1,2,3,4,5,6,7,8,9,10};
	my_memmove(arr+3,arr,20);
	for(int i=0;i<10;i++)
	{
		printf("%d ",arr[i]);
	}
	return 0;
}

 

当原地址大于目标地址时从前向后拷贝，否则从后向前拷贝即可防止内存覆盖导致拷贝出错，模拟实现memmove函数功能。