memcopy和memmove 区别（另strcpy(), strncpy()和memset()）

1.memmove

函数原型：void *memmove(void *dest, const void *source, size_t count)

返回值说明：返回指向dest的void *指针

参数说明：dest,source分别为目标串和源串的首地址。count为要移动的字符的个数

函数说明：memmove用于从source拷贝count个字符到dest，如果目标区域和源区域有重叠的话，memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中。

  void *MemMove(void *dest,const void *src,size_t n) { if(n == 0) return 0; if(dest == NULL) return 0; if(src == NULL) return 0; char *psrc = (char*)src; char *pdest = (char*)dest; //检查是否有重叠问题 if((dest <= psrc) || (pdest >= psrc+n)) { //正向拷贝--Non-Overlapping Buffers copy from lower addresses to higher addresses for(int i=0;i<n;i++) { *pdest = *psrc; psrc++; pdest++; } } else { //反向拷贝--Overlapping Buffers copy from higher addresses to lower addresses psrc += n; pdest += n; for(int i=0;i<n;i++) { psrc--; pdest--; *pdest = *psrc; } } return dest; } 

2.memcpy

 

函数原型：void *memcpy(void *dest, const void *source, size_t count);

返回值说明：返回指向dest的void *指针

函数说明：memcpy功能和memmove相同，但是memcpy中dest和source中的区域不能重叠，否则会出现未知结果。

 

 void *MemCopy(void *dest,const void *src,size_t n) { if(NULL == dest) return 0; if(NULL == src) return 0; char *pdest = (char*)dest; char *psrc = (char*)src; while(n--) //不对是否存在重叠区域进行判断 *pdest++ = *psrc++; //*pdest++相当于*(pdest++)--先取*pdest，再pdest++ return dest; }   

3.两者区别

  函数memcpy()   从source  指向的区域向dest指向的区域复制count个字符，如果两数组重叠，不定义该函数的行为。  
  而memmove(),如果两函数重叠，赋值仍正确进行。

  memcpy函数假设要复制的内存区域不存在重叠，如果你能确保你进行复制操作的的内存区域没有任何重叠，可以直接用memcpy；  
  如果你不能保证是否有重叠，为了确保复制的正确性，必须用memmove。

 

    

测试程序（其中用到了上面的两个函数及对应的库函数）：

//该程序在gcc下编译验证 #include <string.h> #include <stdio.h> int main() { int a[10]; for(int i=0; i < 10; i++) a[i] = i; MemCopy(&a[4],a,sizeof(int)*6); //结果为：0 1 2 3 0 1 2 3 0 1 //memcpy(&a[4], a, sizeof(int)*6); //结果为：0 1 2 3 0 1 2 3 0 1(vc下和下面一个相同) //MemMove(&a[4],a,sizeof(int)*6); //结果为：0 1 2 3 0 1 2 3 4 5 //memmove(&a[4],a,sizeof(int)*6); //结果为：0 1 2 3 0 1 2 3 4 5 //MemMove(a,&a[4],sizeof(int)*6); //结果为：4 5 6 7 8 9 6 7 8 9 //memmove(a, &a[4], sizeof(int)*6);//结果为：4 5 6 7 8 9 6 7 8 9 //memcpy(a, &a[4], sizeof(int)*6); //结果为：4 5 6 7 8 9 6 7 8 9 //MemCopy(a,&a[4],sizeof(int)*6); //结果为：4 5 6 7 8 9 6 7 8 9 for(i = 0; i < 10; i++) printf("%d ",a[i]); printf("/n"); return 0; }   

 

  

 

程序分析：

 这两个函数的函数原型（除了名字）是一样的：
void *memcpy(void *dst, const void *src, size_t count):
void *memmove(void *dst, const void *src, size_t count);
它们都是从src所指向的内存中复制count个字节到dst所指内存中，并返回dst的值。当源内存区域和目标内存区域无交叉时，两者的结果都是一样的。但有交叉时不一样。源内存和目标内存交叉的情况有以下两种：（左边为低地址）

 

1、


即：dst<=src 且 dst+count>src

2、

即：src<dst且src+count>dst
下面将针对这两种情况来讨论。针对第一种交叉情况情况，dst<src且dst+count>src，memcpy和memmove的结果是一样的。请看下面的例子讲解：
int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
memcpy(a, a+4, sizeof(int)*6);和memmove(a, a+4, sizeof(int)*6);结果是：
4567896789

针对第二种情况，src<dst且src+count>dst，memcpy和memmove的结果是不一样的。请看下面的例子：
int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
memcpy(a+4, a, sizeof(int)*6)

 

memmove(a+4, a, sizeof(int)*6)

 

上面图示来自 http://hi.baidu.com/lkmoses/blog/item/3c553dc4778701169c163d57.html
 

 

总结：

两者的功能基本相同，唯一不同的是，当 dest 和 src 有重叠的时候选用不同的函数可能会造成不同的结果。
     对比上面执行结果，不难得出以下结论：
1. 当 src 和 dest 所指内存区有重叠时，memmove 相对 memcpy 能提供保证：保证能将 src 所指内存区的前 n 个字节正确的拷贝到 dest 所指内存中；
2. 当 src 地址比 dest 地址低时，两者结果一样。换句话说，memmove 与 memcpy 的区别仅仅体现在 dest 的头部和 src 的尾部有重叠的情况下；

 

                即：从高向低复制都可以，从低向高复制用memmove() 

 

 

 

memcpy的返回值设计成void   *是有目的的，是便于嵌套使用memcpy、memmove等函数。

 

 

 

 

 

=================memset(),strcpy(), strncpy()====================

 

1.strcpy(), 字符串拷贝.
char *strcpy(char *strDest, const char *strSrc)
{
    assert((strDest!=NULL) && (strSrc !=NULL));
    char *address = strDest;    
    while( (*strDest++ = * strSrc++)·1 != '/0')
       NULL ;
    return address ;      
}

---------------------------------------------------------

附：((*strDest++=*strSrc++)!='/0'); 执行过程
    ++后增运算符优先级高于*
    1.*strDest++相当于 *(strDest++)
    2.由于是后自增，故执行顺序为：
               *strDest=*strSrc
               strDest++ strsrc++ //该级顺序不明
              将*strDest与'/0'比较 //即，整个表达式的值为*strDest与'/0'的比较结果
    值得注意的是，对于赋值表达式，表达式本身的值等于左边子表达式的值。
    通过以上深入的分析，我们知道这个表达式完成了以下多个功能：
    　　1.对于指针strDest, strSrc，将strSrc所指的内存空间的值赋给由strDest所指的内存空间。
    　　2.判断赋值后的strDest所指的内存空间的指是否等于0。
    　　3.对于指针strDest,strSrc,他们的值分别加1，即指向下一个元素。

--------------------------------------------------------- 

2.memset(),把buffer所指内存区域的前count个字节设置成字符c

 函数原型：
extern void *memset(void *s, int c, size_t n)
功能：将已开辟内存空间s的首n个字节的值设为值c。将s中的前n个字符替换为c，并返回s。
memset常用于内存空间的初始化。
memset的深刻内涵：用来对一段内科空间全部设置为某个字符，一般用在对定义的字符串进行初始化为：memset(a, ‘/0’, sizeof(a));

void * Memset(void* buffer, int c, int count)
{
    char* pvTo=(char*)buffer;
    assert(buffer != NULL);
    while(count-->0)
        *pvTo++=(char)c;
    return buffer;
}

 

strcpy：字串复制

　　原型：char *strcpy(char *dest, char *src);

　　功能：把src所指由'/0'结束的字符串复制到dest所指的数组中。

　　说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。

　　返回指向dest的指针。

　　注意：当src串长度>dest串长度时，程序仍会将整个src串复制到dest区域，可是dest数组已发生溢出。

　　因此会导致dest栈空间溢出以致产生崩溃异常。如果不考虑src串的完整性，可以把dest数组最后一元素置为NULL，从dest串长度处插入NULL截取字串。

strncpy：字串复制

     原型：char * strncpy(char *dest, char *src, size_t n);

　　功能：将字符串src中最多n个字符复制到字符数组dest中(它并不像strcpy一样遇到NULL就开始复制，而是等凑够n个字符才开始复制），返回指向dest的指针。

　　说明：

　　如果：   n > dest长度，dest栈空间溢出产生崩溃异常。

　　否则：

　　1）src长度<=dest长度,(这里的串长度包含串尾NULL字符)

　　    如果n=(0, src串长度)，src的前n个字符复制到dest中。但是由于没有NULL字符，所以直接访问dest串会发生栈溢出的异常情况。

　　    如果n = src长度，与strcpy一致。

　　    如果n = dest长度，[0,src长度]处存放src字串，(src长度, dest长度]处存放NULL。

　　2）src串长度>dest串长度

　　    如果n =dest串长度，则dest串没有NULL字符，会导致输出会有乱码。如果不考虑src串复制完整性，可以将dest最后一字符置为NULL。

　　综上，使用strncpy时，建议将n置为dest长度（除非你将多个src串都复制到dest数组，并且从dest尾部反向操作)，复制完毕后，为保险起见，将dest串最后一字符置NULL，避免发生在第2)种情况下的输出乱码问题。当然，无论是strcpy还是strncpy，保证src长度<dest长度才是最重要的。

 

总结：

     strcpy
src长>dest长，则将src长中等于dest长的字符拷贝到dest字符串
如果src长<dest长，则src长全部拷贝到dest字符串，不包括'/0'
     strncpy
如果dest长>n>src长，则将src长全部拷贝到dest串，自动加上'/0'
如果n<src长，则将src长中按指定长度拷贝到dest字符串，不包括'/0'
如果n>dest长，error happen!

 

 

 

 

 ====================================================

 

另：

很好的实例:

char s[]="123456789";
char d[]="123";
strcpy(d,s);

printf("d=%s/n s=%s/n",d,s);

答案：结果是 d=123456789    s=56789
原因是关于程序的栈中存放规则。因为s先声明，所以先存放，另外入栈顺序是从右边开始的。具体存放如下所示：
栈底----->栈顶
/0 987654321 /0 321
strcpy是以/0为结束符的。所以存放的结果是
栈底----->栈顶
/0 987 /0 987654321
因为s指向的位置是5，而d指向的位置是1，(注意s和d指向的栈的位置根本没有变化)
所以输出的话结果是：
s=56789
d=123456789

如果改为memcpy，如
memcpy(d,s,4);则执行后的栈布局如下所示：
栈底----->栈顶
/0 987654321 4 321
所以结果是d=1234123456789
而s根据头指针未变，所以还是原来的s=123456789

 

应用：

一、数组循环移动 。

编写一个函数，作用是把一个char组成的字符串循环右移n个。比如原来是“abcdefghi”如果n=2，移位后应该是“hiabcdefgh”
函数头是这样的：
//pStr是指向以'/0'结尾的字符串的指针
//steps是要求移动的n

//循环右移
void RightLoopMove( char *pStr, int steps)
{
     int stp=steps%strlen(pStr);
     int n=strlen(pStr)- stp;
     char tmp[MAX_LEN];
     memcpy(tmp, pStr+n,stp);
     memcpy(pStr+stp, pStr,n);
     memcpy(pStr,tmp,stp);
}

//循环左移
void LeftLoopMove( char *pStr, int steps)
{
   int len=strlen(pStr);
   int n=steps%len;
   char tmp[MAX_LEN];
   memcpy(tmp, pStr,n);
   memcpy(pStr, pStr+n,len-n);
   memcpy(pStr+len-n,tmp,n);
}

int main(int argc, char* argv[])
{
   char a[]="123456789";
   char b[]="123456789";
   RightLoopMove(a,11);
   LeftLoopMove(b,11);
   printf("%s/n%s/n",a,b);
   return 0;
}

二、memcpy在结构体struct中的使用
已知WAV文件格式定义为结构体WAVEFORMAT
typedef struct tagWaveFormat
{
　char cRiffFlag[4];
　UIN32 nFileLen;
   ……
　char cDataFlag[4];
　UIN16 nAudioLength;

} WAVEFORMAT;
假设WAV文件内容读出后存放在指针buffer开始的内存单元内，则分析文件格式的代码很简单，为：
WAVEFORMAT waveFormat;
memcpy( &waveFormat, buffer,sizeof( WAVEFORMAT ) );
直接通过访问waveFormat的成员，就可以获得特定WAV文件的各项格式信息。