void* mymemcpy( void* dest, const void* src, size_t count )

void* mymemcpy( void* dest, const void* src, size_t count )
{
        assert(dest!=NULL);
        assert(src!=NULL);
        char* pdest=(char*)dest;
        char* psrc=(char*)src;
        if(psrc<pdest&&psrc+count>pdest)
        {
                psrc=psrc+count-1;
                pdest=pdest+count-1;
                while(count-->0)
                        *pdest--=*psrc--;
         }
         else
         {
                while(count-->0)
                       *pdest++=*psrc++;
          }
          return dest;
}

注意防止地址有重叠部分，还有指针类型转换，这是常规实现方法；

void* mymemcpy( void* dest, const void* src, size_t count )  

{                                                                                  

    char* d = (char*)dest;                                                 

    const char* s = (const char*)src ;                                 

    int n = (count + 7) / 8; // count > 0 assumed                   

    switch( count & 7 )                                                      

    {                                                                              

    case 0:  do {  *d++ = *s++;                                         

    case 7:        *d++ = *s++;                                           

    case 6:        *d++ = *s++;                                           

    case 5:        *d++ = *s++;                                           

    case 4:        *d++ = *s++;                                           

    case 3:        *d++ = *s++;                                           

    case 2:        *d++ = *s++;                                           

    case 1:        *d++ = *s++;                                           

               } while (--n > 0);                                             

    }                                                                              

    return dest;                                                                

}       

这程序写的太变态了，乍一看，不知所云，细看一下，琢磨一下还可以：

摘自原贴:

int n = (count + 7) / 8;计算要复制的轮数（每轮复制8位），剩下的余数位数也要复制进去。
count & 7控制要复制余数位数，while (--n > 0)控制轮数。
比如count = 9，则n = 2，count & 7 = 1，要复制2轮，程序跳到case1执行，复制一位之后，再循环一轮，复制8位.

为何这么实现:引用上面帖子后面的评论:

每8个字节拷贝省7个跳转（AMD处理器内部分支预测算法是“假定全都跳转”，因此这里也就是相当于省了7个时钟周期）；把swith和do循环凑到一起，多少省几个字节的空间…… 
但使用32位或64位指令，可以得到更大的优化效果，代码还要精炼得多。 
说实在话：除非内存小到极点、并且无法增加的系统，写出这样的程序纯属作孽……