分享

更多

   

memcopy和memmove 区别(另strcpy(), strncpy()和memset()) 收藏

2011-03-17  千杯不醉0...

   memcopymemmove 区别(另strcpy(), strncpy()memset() 收藏

1.memmove

 

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

 

返回值说明:返回指向destvoid *指针

 

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

 

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

 

  view plaincopy to clipboardprint?

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;  

} 

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);

 

返回值说明:返回指向destvoid *指针

 

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

 

 

 

 view plaincopy to clipboardprint?

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;  

} 

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

 

   

 

测试程序(其中用到了上面的两个函数及对应的库函数):

 

view plaincopy to clipboardprint?

//该程序在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;    

}  

//该程序在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<dstsrc+count>dst

下面将针对这两种情况来讨论。针对第一种交叉情况情况,dst<srcdst+count>srcmemcpymemmove的结果是一样的。请看下面的例子讲解:

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<dstsrc+count>dstmemcpymemmove的结果是不一样的。请看下面的例子:

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   *是有目的的,是便于嵌套使用memcpymemmove等函数。

 

=================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所指的数组中。

 

  说明:srcdest所指内存区域不可以重叠且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栈空间溢出产生崩溃异常。

 

  否则:

 

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

 

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

 

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

 

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

 

  2src串长度>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(注意sd指向的栈的位置根本没有变化)

所以输出的话结果是:

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文件的各项格式信息。

 

 

 

 

    本站是提供个人知识管理的网络存储空间,所有内容均由用户发布,不代表本站观点。如发现有害或侵权内容,请点击这里 或 拨打24小时举报电话:4000070609 与我们联系。

    猜你喜欢
    发表评论评论公约
    喜欢该文的人也喜欢 更多