memcpy与memmove的实现

/*
  memcpy是不管有否区域重叠的，重叠不重叠照样复制，
  memmove才会避免区域重叠，检测这个区域重叠很简单，如果目标地址在源区域内，那就会发生重叠.
  处理重叠也很简单，从源地址的末尾开始反方向复制就OK了。

未重叠的情况:

 内存布局(little endian):
 higher address                           lower address 

   |--------------------------------------|

                                src

                  |------------|

    |-----------|                |------------|

                dest                            dest

目标区域的首地址在源区域内，就发生重叠了。

                       higher address              src(lower address)
                             |---------------------|
          |---------------------|
                                  dest
              
*/

//下面是memmove源码的一段：


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

/* ============== my_memmove() ==============*/
#if 1
void *my_memmove(void *dest, const void *src, size_t n)
{
    void *pdest = dest;
    if(NULL == dest && NULL == src && (n == 0))
    {
        return;
    }

    if((dest <= src) || (char *)dest >= ((char *)src + n))
    {
        /*
         * Non Overlapping Buffers
         * copy from lower address to higher address
         * 正向拷贝
         */
        while(n--)
        {
            *(char *)dest = *(char *)src;
            dest = (char *)dest + 1;
            src = (char *)src + 1;
        }
    }
    else
    {
        /*
         * Overlapping Buffers
         * copy from higher address to lower address
         * 反向拷贝
         */
        dest = (char *)dest + n - 1;
        src = (char *)src + n - 1;
        
        while(n--)
        {
            *(char *)dest = *(char *)src;
            dest = (char *)dest - 1;
            src = (char *)src - 1;
        }
    }

    return pdest;
}
#else

void* my_memmove(void *dest, const void *src,size_t n)
{
    if(NULL == dest && NULL == src && (n == 0))
    {
        return;
    }

    int i;
    char *pdest = (char *)dest;
    char *psrc = (char *)src;
    
    if((pdest <= psrc) || (pdest >= psrc + n))
    {
        /* 正向拷贝 */
        for(i = 0; i < n; ++i)
        {
            *pdest++ = *psrc++;
        }
    }
    else
    {
        /* 反向拷贝 */
        pdest = pdest + n -1;
        psrc = psrc + n - 1;
        
        for(i = 0; i < n; ++i)
        {
            *pdest-- = *psrc--;
        }
    }

    return dest;
}
#endif

/* =============== my_memcpy() ==============*/

//pDest < pSrc 顺序拷贝，否则逆序
#if 1
void *my_memcpy(void *dest, const void *src, size_t n)
{
    char *pdest = (char*)dest;
    const char *psrc = (char *)src;
    size_t i;

    if(NULL == dest && NULL == src && (n == 0))
    {
        return;
    }

    if((pdest > psrc) && (pdest < psrc + n))
    {
        /* 反向拷贝 */
        for(i = n - 1; i <= 0; ++i)
        {
           pdest[i] = psrc[i];
        }
    }
    else
    {
        /* 正向拷贝 */
        for(i = 0; i < n; ++i)
        {
            pdest[i] = psrc[i];
        }
    }
    pdest = '\0';

    return pdest;
}

#else

/* ================ libc ==================*/
void *memcpy(void *dst, const void *src, size_t n)
{
    void *ret = dst;
    if(NULL == src && NULL == dst)
    {
        return;
    }

    while(n--)
    {
        *(char *)dst = *(char *)src;
        dst = (char *)dst + 1;
        src = (char *)src + 1;
    }
    return ret;
}
#endif

/*

c++ 版: pDest < pSrc 顺序拷贝，否则逆序

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;
}

*/

/*

另一个单不考虑不重叠的情况: memcpy, 拷贝不重叠的内存块
void *memcpy(void* pvTo, void* pvFrom, size_t size)
{
    assert(pvTo != NULL && pvFrom != NULL);

    void* pbTo = (char *)pvTo;
    void* pbFrom = (char *)pvFrom;  

    /* 内存块重叠吗？如果重叠，就使用memmove */
    assert(pbTo>=pbFrom+size || pbFrom>=pbTo+size);
    while(size--)
    { 

        *pbTo++ == *pbFrom++;
    }

    return pvTo;
}

*/

int main(int argc, char *argv[])
{
    char *str = "I'm study c";
    char *dst = NULL;
    
    dst = (char *)malloc(sizeof(char) + 1 * sizeof(char));

    printf("after call my_memmove():\n");
    my_memmove(dst, str, strlen(str));
    printf("dst = %s\n", dst);

    printf("after call my_memcpy():\n");
    my_memcpy(dst, str, strlen(str));
    printf("dst = %s\n", dst);

    free(dst);

    return 0;
}