strcpy、memcpy、memmove的區別

strcpy和memcpy都是標准C庫函數，它們有下面特點：

strcpy提供了字符串的復制。即strcpy只用於字符串復制，並且它不僅復制字符串內容外，還會復制字符串的結束符。

strcpy的函數原型是：char* strcpy(char* dest, const char* src);

 

memcpy只提供一般的內存復制，即memcpy對於需要復制的內容沒有限制，因此用途更廣。

memcpy的函數原型是：void *memcpy(void *dest,  const char* src,  size_t count);

 

 
           
            1  
           char *strcpy( 
           char *dest,  
           const  
           char *src) 
           
 
            2 { 
           
 
            3      
           if((src == NULL) || (dest == NULL)) 
           
 
            4     { 
           
 
            5           
           return NULL; 
           
 
            6     } 
           
 
            7  
           
 
            8      
           char *strdest = dest;  
           // 
            保存目標字符串的首地址 
           
 
            9  
                
           while((*dest++ = *str) !=  
           ' 
           \0 
           '); 
           
 
           10      
           return strdest; 
           
 
           11 } 
           
         

 

 

 
          void *memcpy( 
          void *memTo,  
          const  
          char *memFrom, size_t size) 
          
{ 
          
      
          if((memTo == NULL) || (memFrom == NULL)) 
          
     { 
          
           
          return NULL; 
          
     } 
          
 
          
      
          char *tempFrom = ( 
          char *)memFrom;  
          // 
          保存memFrom的首地址 
          
      
          char *tempTo = ( 
          char *)memTo;  
          // 
          保存memTo的首地址 
          
       
          while(size-- >  
          0) 
          
     { 
          
          *tempTo++ = *tempFrom++; 
          
     } 
          
      
          return memTo; 
          
} 
         

 

strcpy 和 memcpy主要有以下三方面的區別：

1、復制的內容不同。strcpy只能復制字符串，而memcpy可以復制任意內容，例如字符串、整型、結構體、類等。

2、復制的方法不同。strcpy不需要指定長度，它遇到被復制字符串的結束符"\0”才結束，所以容易溢出。memcpy則是根據第3個參數決定復制的長度。

3、用途不同。通常在復制字符串時用strcpy，而需要復制其它類型的數據是用memcpy。

 

memcpy 和 memmove 都是C語言中的庫函數，在庫函數 string.h中，其原型相似，它們都是從src所指向的內存中復制count個字節到dest所指內存中。並返回dest的值。

當源內存區域 和 目標內存區域無交叉重疊時，兩者的結果是一樣的，但如果有交叉呢？

memcpy是從src的其實部分開始復制，所以雖然第一種情況下沒有問題，但如果遇到第二種情況，則會發生錯誤，交叉部分的src內容就會被覆蓋掉了。

而memmove則由於采用不同的復制機制，所以可以正確處理第二種情況。

 

 

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