C++ strcpy，memcpy，memset，strcmp，memcmp

strcpy

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

功能：把src所指由’\0’结束的字符串复制到dest所指的数组中。 src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。返回指向dest的指针。

#include<string.h>
#include<iostream.h>

void main(){
char a[20],c[]="i am teacher!";
strcpy(a,c);
cout<<a<<endl;
}

此小例子中，char c[]={‘i’,’ ‘,‘a’,‘m’,’ ‘,‘t’,‘e’,‘a’,‘c’,‘h’,‘e’,‘r’,’\0’};字符串一般默认后面有一个结束符，当用到strcpy(a,c);函数时，把c中的字符串复制到a中，当遇到字符串中默认的结束符后，复制结束。

memcpy

原型：extern void *memcpy(void *dest, void *src, unsigned int count);

功能：由src所指内存区域复制count个字节到dest所指内存区域。 src和dest所指内存区域不能重叠，函数返回指向dest的指针。可以拿它拷贝任何数据类型的对象。

#include <stdio.h>
#include <string.h>
int main()
 {
    char *s="Golden Global View";//此字符串总共有18个字符，再加上一个结束符，总共存放19个字符
    char d1[20],d2[20];
    memcpy(d1,s,(strlen(s)+1));//用memcpy函数，把s中字符串的首地址拷贝到d中，连续复制19个字符

memcpy(d2,s+14,5); //从第14个字符(V)开始复制，连续复制4个字符(View)
    printf("%d\n",strlen(s));
    printf("%s\n",d1);

printf("%s\n",d2);
    return 0;
 }

memset

原型：extern void *memset(void *buffer, int c, int count);

功能：把buffer所指内存区域的前count个字节设置成字符c。用来对一段内存空间全部设置为某个字符。 返回指向buffer的指针。

#include <stdio.h>
#include <memory.h>
 #include <string.h>
 int main()
 {
 char s[]="Golden Global View";
 memset(s,'G',6);//把s中的前6个字符改成G，也就是把Golden改成GGGGGG
 printf("%s\n",s);//输出为GGGGGG Global View
 return 0;
 }

strcmp

原型：extern int strcmp(const char *s1,const char *s2);

功能：两个字符串自左向右逐个字符相比（按ASCII值大小相比较），直到出现不同的字符或遇’\0’为止。当s1<s2时，返回为负数；当s1=s2时，返回值= 0；当s1>s2时，返回正数。

memcmp

原型：extern int memcmp(const void *str1, const void *str2, size_t n);

功能：其功能是把存储区 str1 和存储区 str2 的前 n 个字节逐字节进行比较。该函数是按字节比较的，因此不能用于比较结构体。

实现一个高效率的memcpy

memcpy的功能是从src的开始位置拷贝n个字节的数据到dest。如果dest存在数据，将会被覆盖。memcpy函数的返回值是dest的指针。memcpy函数定义在string.h头文件里。

自己实现的时候，最简单的方法是用指针按照字节顺序复制即可。但是性能太低，主要由以下两个原因：

1. 一次一个字节效率太低，地址总线一般是32位，能搬运4字节，一次一个肯定慢的不行。
2. 当内存区域重叠时会出现混乱情况。

一下根据以上两方面考虑提高memcpy函数的性能。

首先考虑速度，可以按照CPU位宽搬运数据，效率更高，代码如下：

void * Memcpy1(void *dst,const void *src,size_t num)
{
	int nchunks = num/sizeof(dst);   /*按CPU位宽拷贝*/

	cout<<"sizeof(dst)是："<<sizeof(dst)<<endl;

	int slice =   num%sizeof(dst);   /*剩余的按字节拷贝*/
	
	unsigned long * s = (unsigned long *)src;
	unsigned long * d = (unsigned long *)dst;
	
	while(nchunks--)
	    *d++ = *s++;
	    
	while (slice--)
	    *((char *)d++) =*((char *)s++);
	    
	return dst;
}

sizeof(dst)是4，即大部分数据每次按照4字节拷贝，最后不足4字节的再分别拷贝。内存区域出现重叠时，这种方法无法规避内存混乱问题。下面的方法能够规避内存重叠的bug，代码如下：

void *Memcpy2(void *dest, const void *src, size_t count)   {    char
*d;    const char *s;  
     if (((int)dest > ((int)src+count)) || (dest < src))  
    {  
    d = (char*)dest;  
    s = (char*)src;  
    while (count--)  
        *d++ = *s++;          
    }    else /* overlap */  
    {  
    d = (char *)((int)dest + count - 1); /* 指针位置从末端开始，注意偏置 */  
    s = (char *)((int)src + count -1);  
    while (count --)  
        *d-- = *s--;  
    }  
      return dest;   }

如果检测到内存区域有重叠部分，则从末端开始对每个字节进行拷贝。

将两种方法结合后能够提高拷贝函数性能，代码如下：

void *Memcpy(void *dest, const void *src, size_t count)  
{  
   cout<<"sizeof(dest)是："<<sizeof(dest)<<endl;
	int bytelen=count/sizeof(dest);	/*按CPU位宽拷贝*/
	int slice=count%sizeof(dest);	/*剩余的按字节拷贝*/
	unsigned int* d = (unsigned int*)dest;  
    unsigned int* s = (unsigned int*)src;  

 if (((int)dest > ((int)src+count)) || (dest < src))  
    {  
    while (bytelen--)  
        *d++ = *s++;  
	while (slice--)  
        *(char *)d++ = *(char *)s++; 
    }  
 else /* overlap重叠 */  
    {  
    d = (unsigned int*)((unsigned int)dest + count - 4); /*指针位置从末端开始，注意偏置 */  
    s = (unsigned int*)((unsigned int)src + count -4);  
    while (bytelen --)  
        *d-- = *s--;  
	d++;s++;
	char * d1=(char *)d;
	char * s1=(char *)s;
	d1--;s1--;
	while (slice --)  
        *(char *)d1-- = *(char *)s1--; 
    }  
 return dest;  
}