memcpy和memmove的粗浅理解

memcpy的时候，src是const的，不可以更改，处理不对src覆盖的情况，比较简单。（就是下图中的红色“非”所在的图）

memove的时候，可以覆盖src，可以安全覆盖src的情况，如下图的上半部分：

线条画在一起，是因为内存地址重合。

上图的下半个图，是src和dst在复制时，地址重叠，不能从src开头开始覆盖，否则复制到dst中，会把src中数据覆盖，要从src+count-1处开始复制到dst+count-1处，

这样也会覆盖src这个地址值，但是src就是可以覆盖的内存。

========================

http://my.oschina.net/renhc/blog/36345

面试中如问到memcpy的实现，那就要小心了，这里有陷阱。

先看下标准memcpy()的解释：

1void *memcpy(void *dst, const void *src, size_t n);

2//If copying takes place between objects that overlap, the behavior is undefined.

注意下面的注释，对于地址重叠的情况，该函数的行为是未定义的。

事实上所说的陷阱也在于此，自己动手实现memcpy()时就需要考虑地址重叠的情况。

另外，标准库也提供了地址重叠时的内存拷贝函数：memmove()，那么为什么还要考虑重写memcpy()函数呢?

因为memmove()函数的实现效率问题，该函数把源字符串拷贝到临时buf里，然后再从临时buf里写到目的地址，增加了一次不必要的开销。

下面给出memcpy()的实现，为了与标准库函数区分，我们实现其包裹函数：

01#include <stdio.h>

02#include <stdlib.h>

03#include <string.h>

04 

05void *Memcpy(void *dst, const void *src, size_t size);

06 

07int main(int argc, char *argv[])

08{

09    char buf[100] = "abcdefghijk";

10    //memcpy(buf+2, buf, 5);

11    Memcpy(buf+2, buf, 5);

12    printf("%s\n", buf+2);

13}

14 

15void *Memcpy(void *dst, const void *src, size_t size)

16{

17    char *psrc;

18    char *pdst;

19 

20    if(NULL == dst || NULL == src)

21    {

22        return NULL;

23    }

24 

25    if((src < dst) && (char *)src + size > (char *)dst) // 自后向前拷贝

26    {

27        psrc = (char *)src + size - 1;

28        pdst = (char *)dst + size - 1;

29        while(size--)

30        {

31            *pdst-- = *psrc--;

32        }

33    }

34    else

35    {

36        psrc = (char *)src;

37        pdst = (char *)dst;

38        while(size--)

39        {

40            *pdst++ = *psrc++;

41        }

42    }

43 

44    return dst;

45}

使用Memcpy()的结果:

1abcdehijk

使用memcpy()的结果:

1abadehijk

可以看到标准库函数的源字符串在拷贝的过程中被污染了。

2011-12-02 任洪彩 [e-mail]

转载请注明出处.

strcpy()、memcpy()、memmove()、memset()的实现

一直想知道内部实现, 现在想看了, 就找了一下.
不错.
strcpy()、memcpy()、memmove()、memset()的实现

 

strcpy(), 字符串拷贝.
char *strcpy(char *strDest, const char *strSrc)
{
    assert((strDest!=NULL) && (strSrc !=NULL));
    char *address = strDest;     
    while( (*strDest++ = * strSrc++) != '\0') 
       NULL ; 
    return address ;       
}

memcpy, 拷贝不重叠的内存块 
void *memcpy(void* pvTo, void* pvFrom, size_t size) //byte是java里的变量类型
{
assert(pvTo != NULL && pvFrom != NULL);
void* pbTo = (byte*)pvTo;
void* pbFrom = (byte*)pvFrom;
/* 内存块重叠吗？如果重叠，就使用memmove */
assert(pbTo>=pbFrom+size || pbFrom>=pbTo+size);
while(size-->0)
    *pbTo++ == *pbFrom++;
return pvTo;
}

void *MemCopy(void *dest,const void *src,size_t count)
{
    char *pDest=static_cast<char *>(dest);
    const char *pSrc=static_cast<const char *>(src);
    if( pDest>pSrc && pDest<pSrc+count )
    {
        for(size_t i=count-1; i<=0; ++i)
        {
            pDest[i]=pSrc[i];
        }
    }
    else
    {
        for(size_t i=0; i<count; ++i)
        {
             pDest[i]=pSrc[i];
        }
    }
    return pDest;
}

void *Memmove(void *Dst, const void*Src,size_t count)
{
assert(Dst && Src);
void* pDst = Dst;
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 ;
   }
}
return pDst;
}

void* memmove(void *dest, const void *src,size_t n) 
{ 
    if (n == 0) return 0; 
    if (dest == NULL) return 0; 
    if (src == NULL)    return 0; 
    char *psrc = (char*)src; 
    char *pdest = (char*)dest; 
    if((dest <= psrc) || (pdest >= psrc + n)) /*检查是否有重叠问题 */ 
        { 
         for(int i=0; i < n; i++) /*正向拷贝*/ 
          { 
           *pdest = *psrc; 
           psrc++; 
           pdest++; 
          } 
        } 
        else /*反向拷贝*/ 
        { 
          psrc += n; 
          pdest += n; 
          for(int i=0;i<n;i++) 
           { 
            psrc--; 
            pdest--; 
            *pdest = *psrc; 
           } 
        } 
   return dest;
}

memset:把buffer所指内存区域的前count个字节设置成字符c

void * Memset(void* buffer, int c, int count)
{
char* pvTo=(char*)buffer;
assert(buffer != NULL);
while(count-->0)
*pvTo++=(char)c;
return buffer;
}

================================

参考   http://www.cppblog.com/zenliang/archive/2013/10/06/131782.html

库函数memcpy()与memmove()实现

根据MSDN文档，当源区域与目标区域存在重叠时，memcpy()函数报错，而memmove()函数可以处理重叠情况！

 1/* 
 2 * 函数名: memcpy 
 3 * 功  能: 从源source中拷贝n个字节到目标destin中 
 4 * 用  法: void *memcpy(void* destin, const void* source, size_t n); 
 5 * 说  明: 内存拷贝
 6*/
 7
 8#include <stdio.h> 
 9#include <conio.h>   //getch头文件
10#include <assert.h>  //assert头文件
11
12typedef unsigned char byte; 
13//typedef unsigned int size_t;
14
15
16/*
17memcpy函数，如果内存重叠则报错
18*/
19//src要保留
20void* memcpy(void* dst,const void* src,size_t count) 
21{
22    byte* pbTo = (byte*)dst; 
23    byte* pbFrom = (byte*)src; 
24    assert(dst!= NULL && src != NULL);//不能存在空指针
25    assert(pbTo >= pbFrom+count || pbFrom >= pbTo + count);//防止内存重叠(overlap) 
26    while (count-- > 0) 
27    { 
28        *pbTo++ = *pbFrom++; 
29    } 
30    return dst; 
31}
32
33/*
34memmove函数，考虑了内存重叠的情况
35*/
36//src可以不保留
37void* memmove(void* dst,const void* src,size_t count) 
38{     
39    byte* pbTo = (byte*)dst; 
40    byte* pbFrom = (byte*)src; 
41    assert(dst != NULL && src != NULL);//不能存在空指针
42    if (dst <= src || pbTo >= pbFrom + count)// 
43    { 
44        while (count-- > 0) 
45        { 
46            *pbTo++ = *pbFrom++; //按递增拷贝
47        } 
48    } 
49    else  //
50    { 
51        pbTo = pbTo + count -1;//overlap的情况，从高位地址向低位拷贝 
52        pbFrom = pbFrom + count -1; 
53        while (count-- > 0) 
54        { 
55            *pbTo-- = *pbFrom--; //按递减拷贝
56        } 
57    } 
58    return dst; 
59}
60