strcpy/memcpy/memmove的区别 【转】

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

在这里重新温习下。

1 .memmove

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

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

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

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

2 .memcpy

函数原型： void * memcpy( void * dest,  const void * 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.  char* strcpy(char*dst,constchar*src) 
   
2.  {
   
3.      char*cp = dst;
   
4.      assert((src!=0)&&(dst!=0));//not　null
   
5.      while(*cp++=*src++)
   
6.          ;
   
7.      return dst;
   
8.  }

memcpy

点击(此处)折叠或打开

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

memove 

点击(此处)折叠或打开

1. memove 
   
2. 
   
3.  void *memmove(void *dst,const void *src,int n) 
   
4.  { 
   
5.      char *dp = (char *)dst; 
   
6.      char *sp = (char *)src; 
   
7.      assert((src!=0)&&(dst!=0)&&(n>0));//not　null 
   
8.      //非重叠 
   
9.      //dp < sp 
   
10.      //dp > (sp+n) 
    
11.      if(sp>dp||(sp+n)<dp) 
    
12.      { 
    
13.          while(n--) 
    
14.              *(dp++) = *(sp++);       
    
15.      }else if(sp<dp)//重叠 (此时条件 sp<dp<(sp+n))如果sp==dp则快速的返回 
    
16.      {//反向拷贝 
    
17.          sp += n; 
    
18.          dp += n; 
    
19.          while(n--) 
    
20.              *(--dp) = *(--sp); 
    
21.      } 
    
22.      return dst; 
    
23.  }