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的长度，这是调用者应该考虑的问题。