memcpy memmove

我看了下crt的实现源码,如下:(略去64位机的)

C/C++ code

    
    
    
    

     
     
     
     
     void
     
     
     
      
     
     
     
     *
     
     
     
      __cdecl memcpy ( 
     
     
     
     void
     
     
     
      
     
     
     
     *
     
     
     
      dst, 
     
     
     
     const
     
     
     
      
     
     
     
     void
     
     
     
      
     
     
     
     *
     
     
     
      src, size_t count ) { 
     
     
     
     void
     
     
     
      
     
     
     
     *
     
     
     
      ret 
     
     
     
     =
     
     
     
      dst; 
     
     
     
     while
     
     
     
      (count
     
     
     
     --
     
     
     
     ) { 
     
     
     
     *
     
     
     
     (
     
     
     
     char
     
     
     
      
     
     
     
     *
     
     
     
     )dst 
     
     
     
     =
     
     
     
      
     
     
     
     *
     
     
     
     (
     
     
     
     char
     
     
     
      
     
     
     
     *
     
     
     
     )src; dst 
     
     
     
     =
     
     
     
      (
     
     
     
     char
     
     
     
      
     
     
     
     *
     
     
     
     )dst 
     
     
     
     +
     
     
     
      
     
     
     
     1
     
     
     
     ; src 
     
     
     
     =
     
     
     
      (
     
     
     
     char
     
     
     
      
     
     
     
     *
     
     
     
     )src 
     
     
     
     +
     
     
     
      
     
     
     
     1
     
     
     
     ; } 
     
     
     
     return
     
     
     
     (ret); }
    
    
    
    

今天,我看到一个面试题上叫实现这个函数,看了下它的参考答案,如下

C/C++ code

    
    
    
    

     
     
     
     
     void
     
     
     
      
     
     
     
     *
     
     
     
     MyMemCopy(
     
     
     
     void
     
     
     
      
     
     
     
     *
     
     
     
     dest,
     
     
     
     const
     
     
     
      
     
     
     
     void
     
     
     
      
     
     
     
     *
     
     
     
     src,size_t count) { 
     
     
     
     char
     
     
     
      
     
     
     
     *
     
     
     
     pDest
     
     
     
     =
     
     
     
     static_cast
     
     
     
     <
     
     
     
     char
     
     
     
      
     
     
     
     *>
     
     
     
     (dest); 
     
     
     
     const
     
     
     
      
     
     
     
     char
     
     
     
      
     
     
     
     *
     
     
     
     pSrc
     
     
     
     =
     
     
     
     static_cast
     
     
     
     <
     
     
     
     const
     
     
     
      
     
     
     
     char
     
     
     
      
     
     
     
     *>
     
     
     
     (src); 
     
     
     
     //
     
     
     
     注意,这里是关键,为什么要这样比较呢?理由何在? 数据重叠区的处理！ 
试试上面2个函数处理重叠数据区的copy 

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

 当dst   <=   src   ||   (char   *)dst   >=   ((char   *)src   +   count)时copy不会overlap，从低地址向高地址copy  
  否则有overlap问题，即src的尾与dst的头重叠，若按上面的复制 方法 ，src的尾部内容在复制前会被dst的头部复写，可以从src尾部开始，以地址   --   的方式copy到des  

 和memcpy相比，src和des有重叠的情况下，memmove可以保证数据的完整性  
   
  memmove保证的原因很简单，就是针对重叠的情况做特殊处理，因此速度会比memcpy慢一些  
   
  具体的算法并不难想啊，画个图，分两种情况    
  1   src的尾部和des的头部重合  
      从src尾部开始，以地址   --   的方式copy到des  
  2   src的头部和des的尾部重合  
      从src头部开始，以地址   ++   的方式copy到des