memcpy() 和 memmove() 有什么区别？

如果源和目的参数有重叠, memmove() 提供有保证的行为。而 memcpy()  则不能提供这样的保证, 因此可以实现得更加有效率。如果有疑问, 最好使用 memmove()。

参考资料: [K&R2, Sec. B3 p. 250]; [ISO, Sec. 7.11.2.1, Sec. 7.11.2.2]; [Rationale, Sec. 4.11.2]; [H&S, Sec. 14.3 pp. 341-2]; [PCS, Sec. 11 pp. 165-6]。

 

参考linux 内核实现：

 

memcpy：

1. /**
2.  * memcpy - Copy one area of memory to another
3.  * @dest: Where to copy to
4.  * @src: Where to copy from
5.  * @count: The size of the area.
6.  *
7.  * You should not use this function to access IO space, use memcpy_toio()
8.  * or memcpy_fromio() instead.
9.  */
10. void * memcpy(void * dest,const void *src,size_t count)
11. {
12.     char *tmp = (char *) dest, *s = (char *) src;
13.     while (count--)
14.         *tmp++ = *s++;
15.     return dest;
16. }

memmove：

1. /* Normally compiler builtins are used, but sometimes the compiler calls out
2.    of line code. Based on asm-i386/string.h.
3.  */
4. #define _STRING_C
5. #include <linux/string.h>
6. #undef memmove
7. void *memmove(void * dest,const void *src,size_t count)
8. {
9.     if (dest < src) { 
10.         __inline_memcpy(dest,src,count);
11.     } else {
12.         char *p = (char *) dest + count;
13.         char *s = (char *) src + count;
14.         while (count--)
15.             *--p = *--s;
16.     }
17.     return dest;
18. } 

memcpy函数假设要复制的内存区域不存在重叠，如果你能确保你进行复制操作的的内存区域没有任何重叠，可以直接用memcpy；   
  如果你不能保证是否有重叠，为了确保复制的正确性，你必须用memmove。   
    
  至于什么是重叠，例如：   
  你要把从0x00000040开始的10个字节的内容复制到从0x00000045开始的区域去，这就存在重叠了！

 

文章二：http://blog.chinaunix.net/u/22520/showart_430430.html

 

memcpy和memmove的区别

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);   它们都是从src所指向的内存中复制count个字节到dst所指内存中，并返回dst的值。当源内存区域和目标内存区域无交叉时，两者的结果是一样的，但如果有交叉呢？先看下图：   图的上半部分为源内存区域在目标内存区域右边，下半部分为源内存区域在目标区域左边，源内存区域和目标内存区域都有交叉。 memcpy（）是从src的起始部分开始复制，所以虽然第一种情况下没有问题，但如果遇到第二种情况，则会发生错误，如图所示，后两个字节在被复制前已经被覆盖掉了。而memmove（）则由于采用了不同的复制机制，所以可以正确处理第二种情况。 VS.NET2003中所附源码如下（有删）： void * __cdecl memcpy (void * dst, const void * src, size_t count) {         void * ret = dst;         /*          * copy from lower addresses to higher addresses          */         while (count--) {                 *(char *)dst = *(char *)src;                 dst = (char *)dst + 1;                 src = (char *)src + 1;         }         return(ret); } void * __cdecl memmove (void * dst, const void * src, size_t count) {         void * ret = dst;         if (dst <= src || (char *)dst >= ((char *)src + count)) {                 /*                  * Non-Overlapping Buffers                  * copy from lower addresses to higher addresses                  */                 while (count--) {                         *(char *)dst = *(char *)src;                         dst = (char *)dst + 1;                         src = (char *)src + 1;                 }         }         else {                 /*                  * Overlapping Buffers                  * copy from higher addresses to lower addresses                  */                 dst = (char *)dst + count - 1;                 src = (char *)src + count - 1;                 while (count--) {                         *(char *)dst = *(char *)src;                         dst = (char *)dst - 1;                         src = (char *)src - 1;                 }         }         return(ret); } 文章三：写程序是一种态度（二）四倍速memmove http://www.chinaitpower.com/A/2001-10-17/2036.html   我提到MS run-time用C来实现函数如strcmp只是算法的表征，相对应的都有asm文件如strcmp.asm才是对其算法的具体的针对Intel指令集的高效实现。如此可以做一个也许不恰当的类比，strcmp.c是一个伪码描述，而strcmp.asm才是具体实现；因为用某种c编译器编译后的strcmp.c很可能没有直接的strcmp.asm更高效，尽管算法的思路没有变化。借着这个话题我们在看一看经典的memcpy和memmove：   void * __cdecl memcpy (         void * dst,         const void * src,         size_t count         ) {         void * ret = dst;           /*          * copy from lower addresses to higher addresses          */         while (count--) {                 *(char *)dst = *(char *)src;                 dst = (char *)dst + 1;                 src = (char *)src + 1;         }           return(ret); }   void * __cdecl memmove (         void * dst,         const void * src,         size_t count         ) {         void * ret = dst;           if (dst <= src || (char *)dst >= ((char *)src + count)) {                 /*                  * Non-Overlapping Buffers                  * copy from lower addresses to higher addresses                  */                 while (count--) {                         *(char *)dst = *(char *)src;                         dst = (char *)dst + 1;                         src = (char *)src + 1;                 }         }         else {                 /*                  * Overlapping Buffers                  * copy from higher addresses to lower addresses                  */                 dst = (char *)dst + count - 1;                 src = (char *)src + count - 1;                   while (count--) {                         *(char *)dst = *(char *)src;                         dst = (char *)dst - 1;                         src = (char *)src - 1;                 }         }           return(ret); }   这里我省掉了 #if defined (_M_MRX000) || defined (_M_ALPHA) || defined (_M_PPC) || defined (_M_IA64) 编译开关里的CODE，针对这些目标机有另外的处理，我们现在只定位于Intel 32-bit上。 1．文档中说的很清楚memcpy不考虑内存重叠，而memmove会考虑，实际上代码中很明显，memcpy只是memmove的一个子集，所以建议总是用memmove这样可以不考虑内存重叠问题。   2．考虑能否用C++去描述更精炼？如从低地址到高地址的赋值可以简单写成：           while (count--) {                 *dst ++ = *src ++;         }   3．c编译器对以上代码编译后所产生的指令是否是一个字节一个字节拷贝？   4．问题3将带来我们对副标题的讨论--四倍速   Intel 80386以上支持的指令集中MOVSD指令和REP指令配合将DWORD（32bit）在内存间移动，即在一个时钟周期copy四个字节，整整比MOVSB（8bit）指令快了四倍。但是使用MOVSD移动到的目的内存地址必须是32bit对齐的（DWORD-aligned）。简单说明从低位到高位的内存copy如下。 设L为要拷贝的总字节数，Dest为目的起始地址，X为从Dest开始没有DWORD-aligned的字节数，Y为要拷贝的DWORD个数，Z为剩余的没有DWORD-aligned字节数。那么有公式如下：   X = (4 – Dest & 3 ) & 3 (bytes)           //低两位为0的地址是DWORD-aligned Y = (L – X) >> 2 (DWORDs)             //整除以4是DWORD个数 Z = (L – X – Y * 4) (bytes)             再做相应的处理。      总结一下，对大段的内存移动，用memmove将是非常优化的，相反若用c写的code会降低四倍效率，这就是为什么要用ASM直接实现的原因。