strcpy()、memcpy()、memmove()、memset()及其应用

一、strcpy()实现, 字符串拷贝.
char *strcpy(char *strDest, const char *strSrc)
{
    assert((strDest!=NULL) && (strSrc !=NULL));
    char *address = strDest;     
    while( (*strDest++ = * strSrc++) != '\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，即指向下一个元素。

    即：该表达式实现了以下三个功能：
    　　1.对于指针strDest, strSrc，将strSrc所指的内存空间的值赋给由strDest所指的内存空间。
    　　2.判断赋值后的strDest所指的内存空间的值是否等于0。
    　　3.对于指针strDest,strSrc,他们的值分别加1，即指向下一个元素。
二、memcpy, 拷贝不重叠的内存块 
void *memcpy(void* pvTo, void* pvFrom, size_t size) //byte是java里的变量类型
{
assert(pvTo != NULL && pvFrom != NULL);
void* pbTo = (byte*)pvTo;
void* pbFrom = (byte*)pvFrom;
/* 内存块重叠吗？如果重叠，就使用memmove */
assert(pbTo>=pbFrom+size || pbFrom>=pbTo+size);
while(size-->0)
    *pbTo++ == *pbFrom++;
return pvTo;
}

很好的实例: 跟小朱探讨很不错
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

三、void *MemCopy(void *dest,const void *src,size_t count)
{
    char *pDest=static_cast<char *>(dest);
    const char *pSrc=static_cast<const char *>(src);
    if( pDest>pSrc && pDest<pSrc+count )
    {
        for(size_t i=count-1; i<=0; ++i)
        {
            pDest[i]=pSrc[i];
        }
    }
    else
    {
        for(size_t i=0; i<count; ++i)
        {
             pDest[i]=pSrc[i];
        }
    }
    return pDest;
}

四、void *Memmove(void *Dst, const void*Src,size_t count)
{
assert(Dst && Src);
void* pDst = Dst;
if (Dst<Src && (char*)Dst > (char*)Src + count)
{
while(count--)
{
   *(char*)Dst = *(char*)Src;
   Dst = (char*)Dst + 1;
   Src = (char*)Src + 1;
}
}
else
{
   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 pDst;
}

五、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)) /*检查是否有重叠问题 */ 
        { 
         for(int i=0; i < n; i++) /*正向拷贝*/ 
          { 
           *pdest = *psrc; 
           psrc++; 
           pdest++; 
          } 
        } 
        else /*反向拷贝*/ 
        { 
          psrc += n; 
          pdest += n; 
          for(int i=0;i<n;i++) 
           { 
            psrc--; 
            pdest--; 
            *pdest = *psrc; 
           } 
        } 
   return dest;
}

memset:把buffer所指内存区域的前count个字节设置成字符c

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

一、数组循环移动。编写一个函数，作用是把一个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文件的各项格式信息。

版权声明：本文为博主原创文章，未经博主允许不得转载。

转载于:https://www.cnblogs.com/wangicter/archive/2012/07/07/4767335.html