C/C++之Memcpy and memmove

memcpy与memmove的目的都是将N个字节的源内存地址的内容拷贝到目标内存地址中。

但当源内存和目标内存存在重叠时，memcpy会出现错误，而memmove能正确地实施拷贝，但这也增加了一点点开销。

memmove的处理措施：

（1）当源内存的首地址等于目标内存的首地址时，不进行任何拷贝

（2）当源内存的首地址大于目标内存的首地址时，实行正向拷贝

（3）当源内存的首地址小于目标内存的首地址时，实行反向拷贝

-- memcpy实现

1	void * memcpy ( void *dest, const void *src, size_t n)

2

{

3	char *d = ( char *) dest;

4	const char *s = ( const char *) src;

5	while (n-–)

6	*d++ = *s++;

7	return dest;

8

}

　

Notes：

memcpy的参数指针类型是void*,具体赋值操作是以字节为单位。

必须进行类型转换。

返回的还是void*型的dest。

-- memmove实现

01	void * memmove ( void *dest, const void *src, size_t n)

02

{

03	char *d = ( char *) dest;

04	const char *s = ( const char *) src;

05

06

if (s>d)

07

{

08	// start at beginning of s

09	while (n--)

10	*d++ = *s++;

11

}

12	else if (s<d)

13

{

14	// start at end of s

15	d = d+n-1;

16	s = s+n-1;

17

18	while (n--)

19	*d-- = *s--;

20

}

21	return dest;

22

}

　示意图：

（1）内存低端 <-----s-----> <-----d-----> 内存高端 start at end of s
（2）内存低端 <-----s--<==>--d----->      内存高端 start at end of s
（3）内存低端 <-----sd----->              内存高端 do nothing
（4）内存低端 <-----d--<==>--s----->      内存高端 start at beginning of s
（5）内存低端 <-----d-----> <-----s-----> 内存高端 start at beginning of s

Notes:

s==d时，什么都不做。

d在前，正向拷贝。

d在后，逆向拷贝。

1.memmove

函数原型：void *memmove(void *dest, const void *source, size_t count)

返回值说明：返回指向dest的void *指针

参数说明：dest,source分别为目标串和源串的首地址。count为要移动的字符的个数

函数说明：memmove用于从source拷贝count个字符到dest，如果目标区域和源区域有重叠的话，memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中。

2.memcpy

函数原型：void *memcpy(void *dest, const void *source, size_t count);

返回值说明：返回指向dest的void *指针

函数说明：memcpy功能和memmove相同，但是memcpy中dest和source中的区域不能重叠，否则会出现未知结果。

原型：extern char *strcpy(char *dest,char *src);  功能：把src所指由NULL结束的字符串复制到dest所指的数组中。  说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串，返回指向dest的指针。

　　其实在strcpy的实现比较多，但思想是一致的，一般用C来实现，但是memcpy和memmove这样的函数可能是用汇编实现的，并且充分利用块拷贝的思想，不会单字节单字节的拷贝。所以效率strcpy<memcpy.

memmove一般由于要判断内存是否重合，效率也会较memcpy低些。

1 /***
2 *@brief 以字节的方式直接拷贝
3 *库中实现是以汇编实现，
4 *其实可以直接调用strncat函数
5 ***/
6 void *memcpy(void *dst,void *src,size_t n)
7 {
8 char *dp = (char *)dst;
9 char *sp = (char *)src;
10 assert((src!=0)&&(dst!=0)&&(n>0));//not　null
11 while(n--)
12 *(dp++) = *(sp++);
13 /**!边界*/
14 dp = '\0';
15 return dst;
16 }


memmove

1 void *memmove(void *dst,const void *src,int n)
2 {
3     char *dp = (char *)dst;
4     char *sp = (char *)src;
5     assert((src!=0)&&(dst!=0)&&(n>0));//not　null
6     //非重叠
7     //dp < sp
8     //dp > (sp+n)
9     if(dp<sp||(sp+n)>=dp)
10     {
11         while(n--)
12             *(dp++) = *(sp++);
13         *dp = '\0';
14     }else if(sp<dp)//重叠 (此时条件 sp<dp<(sp+n))如果sp==dp则快速的返回
15     {//反向拷贝
16         sp += n;
17         dp += n;
18         *dp = '\0';
19         while(n--)
20             *(--dp) = *(--sp);
21     }
22     return dst;
23 }

　注意对于重合的要反向拷贝

/*
*Magicman
*myMemcpy.c
*不调用库函数，实现内存拷贝
*/

#include <stdio.h>

#include <assert.h>

#include <stdlib.h>

void *myMemcpy(void *dest, const void *src, int len)

{

assert((dest != NULL) && (src != NULL) && (len >= 0));

if (dest == src)

{

return dest;

}

while (len-- > 0)

{

*(char *)dest++ = *(char *)src++;

}

return dest;

}

int main(int argc, char argv[])

{

char str[20] = "Testing myMemory!";

char pstr[20] = "";

char *pp = str;

int ia[10] = {1,2,3,4,5,6,7,8,9,10};

int ib[10] = {};

int *ip = NULL;

myMemcpy((void *)pstr, (void *)str, sizeof(str));

printf("%s/n", pstr);

printf("%s/n", myMemcpy((void *)pp, (void *)str, 20));

myMemcpy((void *)ib, (void *)ia, 5*sizeof(int));

for (ip = ib; ip < ib + 10; ip++)

{

printf("%d ", *ip);

}

printf("/n");

return 0;

}

让自己实现memcpy库函数，要求考虑特殊情况，两段内存存在覆盖，以及指针为空的情况。

几点结论：
1，memcpy实现从源source中拷贝n个字节到目标destin中，src源数据应该保留。
2，memmove实现移动一块字节，src源数据可以不保留。
3，memcpy没有考虑内存覆盖问题(由assert条件可知)；而memmove考虑了内存覆盖问题，并给出了解决办法。
4，memcpy和memmove中不需要考虑数组越界问题，dst的长度应该大于src的长度，这是调用者应该考虑的问题。