memcpy实现

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

先看下标准memcpy()的解释：注意下面的注释，对于地址重叠的情况，该函数的行为是未定义的。

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

另外，标准库也提供了地址重叠时的内存拷贝函数：memmove()，那么为什么还要考虑重写memcpy()函数呢?因为memmove()函数的实现效率问题，该函数把源字符串拷贝到临时buf里，然后再从临时buf里写到目的地址，增加了一次不必要的开销。

<span style="font-size:14px;">void*Memcpy(void *dst, const void *src, size_t size);
 
int main(intargc, char *argv[])
{
    char buf[100] = "abcdefghijk";
    memcpy(buf+2, buf, 5);
    //Memcpy(buf+2, buf, 5);
    printf("%s\n", buf+2);
 
         return 0;
}
 
void*Memcpy(void *dst, const void *src, size_t size)
{
    char *psrc;
    char *pdst;
        
    if(NULL == dst || NULL == src)
    {
        return NULL;
    }
        
    if((src < dst) && (char *)src +size > (char *)dst) // 自后向前拷贝
    {
        psrc = (char *)src + size - 1;
        pdst = (char *)dst + size - 1;
        while(size--)
        {
            *pdst-- = *psrc--;
        }
    }
    else
    {
        psrc = (char *)src;
        pdst = (char *)dst;
        while(size--)
        {
            *pdst++ = *psrc++;
        }
    }
        
    return dst;
}

以前没注意过多字节赋值问题，考虑的角度是充分利用 cpu 的 32 位带宽。一次复制 1 个字节和一次复制 4 个字节占用的 cpu 指令周期是一样的，既然我们的 cpu 能同时操作 32 位，为什么我们不能一次复制 4 个字节呢？如此一来，总运行的指令数将降低到原来的 1/4 ！

代码
 void *memcpy(void *dest, void *src, size_t count)
 {
     size_t c = count >> 2; /* 相当于 count / 4 */
     long *pt;
     const long *ps;
     if (c)
     {
         /* 首先按 4 个字节复制 */
         pt = (long *) dest;
         ps = (const long *) src;
         while (c)
         {
             *pt = *ps;
             pt++;
             ps++;
             c--;
         }
     }
     c = count & 3; /* 得到 count 模 4 的余数 */
     if (c)
     {
         /* 如果有剩下的，再按 1 个字节复制剩余的 */
         char *pct = (char *) pt;
         const char *pcs = (const char *) ps;
         while (c)
         {
             *pct = *pcs;
             pct++;
             pcs++;
             c--;
         }
     }
     return dest;
 }