strcpy/memcpy/memmove的实现

今天看某个面试题，实现memcpy，吓了一跳，怎么还要求考虑内存重合啊。印象中不是这样子的啊。于是将以前写的代码翻出来看了看。

在这里重新温习下。

1.memmove

函数原型：void*memmove(void*dest, constvoid*source, size_t count)

返回值说明：返回指向dest的void *指针

参数说明：dest,source分别为目标串和源串的首地址。count为要移动的字符的个数

函数说明：memmove用于从source拷贝count个字符到dest，如果目标区域和源区域有重叠的话，memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中。

2.memcpy

函数原型：void*memcpy(void*dest, constvoid*source, size_t count);

返回值说明：返回指向dest的void *指针

函数说明：memcpy功能和memmove相同，但是memcpy中dest和source中的区域不能重叠，否则会出现未知结果。

原型：extern char *strcpy(char *dest,char *src);
功能：把src所指由NULL结束的字符串复制到dest所指的数组中。
说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串，返回指向dest的指针。

　　其实在strcpy的实现比较多，但思想是一致的，一般用C来实现，但是memcpy和memmove这样的函数可能是用汇编实现的，并且充分利用块拷贝的思想，不会单字节单字节的拷贝。所以效率strcpy<memcpy.

memmove一般由于要判断内存是否重合，效率也会较memcpy低些。

strcpy

1 /********字符串的拷贝*****/
2 char* strcpy(char*dst,constchar*src)                                                                                     
3 {
4 char*cp = dst;
5     assert((src!=0)&&(dst!=0));//not　null
6 while(*cp++=*src++)
7         ;
8 return dst;
9 }

memcpy

 1 /***
 2  *  @brief 以字节的方式直接拷贝
 3  *      库中实现是以汇编实现，
 4  *      其实可以直接调用strncat函数
 5  * **/
 6 void*memcpy(void*dst,void*src,size_t n)
 7 {
 8 char*dp = (char*)dst;
 9 char*sp = (char*)src;
10     assert((src!=0)&&(dst!=0)&&(n>0));//not　null
11 while(n--)
12 *(dp++) =*(sp++);
13 /**!边界*/
14     dp ='\0';
15 return dst;
16 }

memove

 void *memmove(void *dst,const void *src,int n)                                                
 {                                                                                             
     char *dp = (char *)dst;                                                                   
     char *sp = (char *)src;                                                                   
     assert((src!=0)&&(dst!=0)&&(n>0));//not　null                                             
     //非重叠                                                                                  
     //dp < sp                                                                                 
     //dp > (sp+n)                                                                             
     if(sp>dp||(sp+n)<dp)                                                                     
     {                                                                                         
         while(n--)                                                                            
             *(dp++) = *(sp++);                                                                
         *dp = '\0';                                                                           
     }else if(sp<dp)//重叠 (此时条件 sp<dp<(sp+n))如果sp==dp则快速的返回                       
     {//反向拷贝                                                                               
         sp += n;                                                                              
         dp += n;                                                                              
         *dp = '\0';                                                                           
         while(n--)                                                                            
             *(--dp) = *(--sp);                                                                
     }                                                                                         
     return dst;                                                                               
 }

注意对于重合的要反向拷贝