c memmove和memcpy的實現和區別

memcpy和memmove（）都是C語言中的庫函數，在頭文件string.h中，做用是拷貝必定長度的內存的內容，原型分別以下：
void *memcpy(void *dst, const void *src, size_t count);

void *memmove(void *dst, const void *src, size_t count); 

他們的做用是同樣的，惟一的區別是，當內存發生局部重疊的時候，memmove保證拷貝的結果是正確的，memcpy不保證拷貝的結果的正確。


第一種狀況下，拷貝重疊的區域不會出現問題，內容都可以正確的被拷貝。
第二種狀況下，問題出如今右邊的兩個字節，這兩個字節的原來的內容首先就被覆蓋了，並且沒有保存。因此接下來拷貝的時候，拷貝的是已經被覆蓋的內容，顯然這是有問題的。
實際上，memcpy只是memmove的一個子集。

兩者的c語言實現很簡單，有興趣的朋友能夠去看看。在實際狀況下，這兩個函數都是用匯編實現的。

memmove在copy兩個有重疊區域的內存時能夠保證copy的正確，而memcopy就不行了，但memcopy比memmove的速度要快一些，如：
char s[] = "1234567890";
char* p1 = s;
char* p2 = s+2;
memcpy(p2, p1, 5)與memmove(p2, p1, 5)的結果就多是不一樣的，memmove()能夠將p1的頭5個字符"12345"正確拷貝至p2，而memcpy()的結果就不必定正確了

memcpy()、 memmove()和memccpy()
-------------------------------------------------------
    這三個函數的功能均是將某個內存塊複製到另外一個內存塊。前兩個函數的區別在於它們處理內存區域重疊(overlapping)的方式不一樣。第三個函數的功能也是複製內存，可是若是遇到某個特定值時當即中止複製。
    對於庫函數來講，因爲沒有辦法知道傳遞給他的內存區域的狀況，因此應該使用memmove()函數。經過這個函數，能夠保證不會出現任何內存塊重疊問題。而對於應用程序來講，由於代碼「知道」兩個內存塊不會重疊，因此能夠安全地使用memcpy()函數。
原型：extern void *memccpy(void *dest, void *src, unsigned char ch, unsigned int count);
　　用法：#include 
　　功能：由src所指內存區域複製很少於count個字節到dest所指內存區域，若是遇到字符ch則中止複製。
　　說明：返回指向字符ch後的第一個字符的指針，若是src前n個字節中不存在ch則返回NULL。ch被複制。
char s[]="Goldenx Global View";
char d[20];
char *p;
p=(char *)memccpy(d,s,'x',strlen(s));
if(p)
{
   *p='\0'; // MUST Do This
   printf("Char found: %s.\n",d);
}
else
   printf("Char not found.\n");

關於memmove的實現：

點擊(此處)摺疊或打開

1. void *mymemmove(void *dest, const void *src, size_t n)
2. {
3.     char temp[n];
4.     int i;
5.     char *d = dest;
6.     const char *s = src;
7.  
8.     for (i = 0; i < n; i++) 
9.         temp[i] = s[i];
10.     for (i = 0; i < n; i++) 
11.         d[i] = temp[i];
12.  
13.     return dest;
14. }

關於memcpy的實現：

點擊(此處)摺疊或打開

1. void *mymemcpy(void *dest, const void *src, size_t n)
2. {
3.     char *d = dest;
4.     const char *s = src;
5.     int *di;
6.     const int *si;
7.     int r = n % 4;
8.     
9.     while (r--)
10.         *d++ = *s++;
11.     di = (int *)d;
12.     si = (const int*)s;
13.     n /= 4;
14.     while (n--)
15.         *di++ = *si++;
16.  
17.     return dest;
18. }

############################################################################

memcpy與memmove的目的都是將N個字節的源內存地址的內容拷貝到目標內存地址中。

但當源內存和目標內存存在重疊時，memcpy會出現錯誤，而memmove能正確地實施拷貝，但這也增長了一點點開銷。

memmove的處理措施：

（1）當源內存的首地址等於目標內存的首地址時，不進行任何拷貝

（2）當源內存的首地址大於目標內存的首地址時，實行正向拷貝

（3）當源內存的首地址小於目標內存的首地址時，實行反向拷貝

-- memcpy實現

1 2 3 4 5 6 7 8

void* memcpy(void* dest, const void* src, size_t n) {     char*      d = (char*) dest;     const char*  s = (const char*) src;     while(n-–)        *d++ = *s++;     return dest; }

　

-- memmove實現

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

void* memmove(void* dest, const void* src, size_t n) {     char*     d  = (char*) dest;     const char*  s = (const char*) src;        if (s>d)     {          // start at beginning of s          while (n--)             *d++ = *s++;     }     else if (s<d)     {         // start at end of s         d = d+n-1;         s = s+n-1;            while (n--)            *d-- = *s--;     }     return dest; }

　示意圖：

（1）內存低端 <-----s-----> <-----d-----> 內存高端 start at end of s
（2）內存低端 <-----s--<==>--d----->      內存高端 start at end of s
（3）內存低端 <-----sd----->              內存高端 do nothing
（4）內存低端 <-----d--<==>--s----->      內存高端 start at beginning of s
（5）內存低端 <-----d-----> <-----s-----> 內存高端 start at beginning of s