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