memmove、memcpy，memcopy简介

memmove、memcpy和memccpy三个函数都是内存的拷贝，从一个缓冲区拷贝到另一个缓冲区。
memmove(void *dest,void*src,int count)
memcpy(void *dest,void *src,int count)
memccpy(void*dest,void*src,int ch,int count)

表头文件: #include <string.h>
定义函数: void *memcpy(void *dest, const void *src, size_t n)
函数说明: memcpy()用来拷贝src所指的内存内容前n个字节到dest所指的内存地址上。与strcpy()不同的是,memcpy()会完整的复制n个字节,不会因为遇到字符串结束'/0'而结束
返回值:   返回指向dest的指针

表头文件: #include <string.h>
定义函数: void *memccpy(void *dest, const void *src, int c, size_t n);
函数说明: memccpy()用来拷贝src所指的内存内容前n个字节到dest所指的地址上。与memcpy()不同的是,memccpy()如果在src中遇到某个特定值(int c)立即停止复制。
返回值:   返回指向dest中值为c的下一个字节指针。返回值为0表示在src所指内存前n个字节中没有值为c的字节。

表头文件: #include <string.h>
定义函数: void *memmove(void *dest, const void *src, size_t n);
函数说明:memmove()是从一个缓冲区移动到另一个缓冲区中。 
返回值:   返回指向dest指针。

当dest <= src 或dest >= src+count时，以上三个函数均不会产生覆盖问题，即源数据不会被更改。
若不在以上范围内，则源数据会被更改。

 

从DESCRIPTION看来，两者的功能基本相同，唯一不同的是，当 dest 和 src 有重叠的时候选用不同的函数可能会造成不同的结果。不妨写个小程序来测一下： 

很简单的小程序！不过已经足以达到我的目的了：）将上面代码gcc之后再运行，结果为：0 1 2 3 0 1 2 3 0 1 。 
再把第13行改成：memmove(&a[4], a, sizeof(int)*6)，重新gcc再运行，结果为：0 1 2 3 0 1 2 3 4 5 ！ 
呵呵，两者的区别出现了。不过其实这样还不够，继续修改13行： memmove(a, &a[4], sizeof(int)*6) //也就是将源、目的置换一下而已 
重新gcc编译再运行，结果为：4 5 6 7 8 9 6 7 8 9 。 
还不够，继续修改13行为： memcpy(a, &a[4], sizeof(int)*6); gcc并运行，结果仍为： 4 5 6 7 8 9 6 7 8 9 ！ 
至此真相已经大白了。对比上面四个结果，不难得出以下结论： 
1. 当 src 和 dest 所指内存区有重叠时，memmove 相对 memcpy 能提供保证：保证能将 src 所指内存区的前 n 个字节正确的拷贝到 dest 所指内存中； 
2. 当 src 地址比 dest 地址高时，两者结果一样。换句话说，memmove 与 memcpy 的区别仅仅体现在 dest 的头部和 src 的尾部有重叠的情况下；

memcpy
代码: 
;***
;memcpy.asm - contains memcpy and memmove routines
;
;       Copyright (c) 1986-1997, Microsoft Corporation. All right reserved.
;
;Purpose:
;       memcpy() copies a source memory buffer to a destination buffer.
;       Overlapping buffers are not treated specially, so propogation may occur.
;       memmove() copies a source memory buffer to a destination buffer.
;       Overlapping buffers are treated specially, to avoid propogation.
;
;*******************************************************************************
;***
;memcpy - Copy source buffer to destination buffer
;
;Purpose:
;       memcpy() copies a source memory buffer to a destination memory buffer.
;       This routine does NOT recognize overlapping buffers, and thus can lead
;       to propogation.
;       For cases where propogation must be avoided, memmove() must be used.
;
;       Algorithm:
       void* memcpy(void* dest, void* source, size_t count)
      {
           void* ret = dest;
          //copy from lower address to higher address
          while (count--)
                  *dest++ = *source++;
 
           return ret;
      }
 
 
memmove
memmove - Copy source buffer to destination buffer
;
;Purpose:
;       memmove() copies a source memory buffer to a destination memory buffer.
;       This routine recognize overlapping buffers to avoid propogation.
;       For cases where propogation is not a problem, memcpy() can be used.
;
;   Algorithm:
    void* memmove(void* dest, void* source, size_t count)
   {
       void* ret = dest;
 
       if (dest <= source || dest >= (source + count))
       {
          //Non-Overlapping Buffers
         //copy from lower addresses to higher addresses
    
         while (count --)
               *dest++ = *source++;
     }
     else
     {
        //Overlapping Buffers
       //copy from higher addresses to lower addresses
 
       dest += count - 1;
       source += count - 1;
       while (count--)
                *dest-- = *source--;
      }
      return ret;
   }