memcpy与memmove的实现

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

未重叠的情况:

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


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

                                src

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

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

                dest                            dest

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

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

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


#include

//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 = '';

    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

*/

/*

另一个单不考虑不重叠的情况: 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 = %sn", dst);

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

    free(dst);

    return 0;
}