strcpy, memcpy和memmove的区别

strcpy只能处理字符串；如果拷贝带有特殊字符的串，就只能用memcpy或memmove。memcpy和memmove功能基本上差不多，但是当源串和目标串有Overlap时，memmove可以正确处理，memcpy则不行。

void* memcpy(void* pvTo, const void* pvForm, size_t size)
{
 assert((pvTo!= NULL) && (pvFrom!= NULL));//使用断言防止传递空地址
 unsigned char* pbTo = (unsigned char*)pvTo;//防止改变pvTo的地址
 unsigned char* pbFrom = (unsigned char*)pvFrom;//防止改变pvFrom的地址
 while(size-- > 0)
 {
  *pbTo++ = *pbFrom++;
 }
 return pvTo;
}

char* strcpy(char* pDest, const char* pSrc)
{
 assert((pDest != NULL) && (pSrc != NULL));
 char *pTmp = pDest;
 while ((*pDest++ = *pSrc++) != '/0')
  ;
 return pTmp;
}

 

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;

        /*
         * 从低地址向高地址依次复制
         */
        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)) {
                /*
                 * 当src和dst无重叠区域时
                 * 从低地址向高地址依次复制
                 */
                while (count--) {
                        *(char *)dst = *(char *)src;
                        dst = (char *)dst + 1;
                        src = (char *)src + 1;
                }
        }
        else {
                /*
                 * 当src和dst有重复区域时

                 * 从高地址向低地址依次复制
                 */
                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);
}

 

不妨写个小程序来测一下：
 
0 ＃i nclude <string.h>
1 ＃i nclude <stdio.h>
2
3 int main()
4 {
5    int i = 0;
6    int a[10];
7  
8    for(i; i < 10; i++)
9    {
10        a[i] = i;
11   }
12
13   memcpy(&a[4], a, sizeof(int)*6);
14 
15   for(i = 0; i < 10; i++)
16   {
17       printf("%d ",a[i]);
18   }
20  
21   printf("/n");
22   return 0;
23 }
 
很简单的小程序！不过已经足以达到我的目的了：）将上面代码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 的尾部有重叠的情况下；

 
本文引自：http://blog.chinaunix.net/u/22520/showart_430430.html