memcpy和memmove函数的编写以及区别分析

void* _memove(void* dest,const void*src,size_t count)
{
    assert((dest != NULL) && (src != NULL));
    assert(count>0);
 
    char* psrc = (char*)src;
    char* pdest = (char*)dest;
 
    //检查是否有重叠问题   
    if(pdest < psrc)
    {
        //正向拷贝   
        while(count--)
            *pdest++ = *psrc++;
    }
    else if(psrc < pdest)
    {
        //反向拷贝   
        psrc = psrc + count;
        pdest = pdest + count;
        while(count--)
            *pdest-- = *psrc--;
    }
 
    return dest;
}
 
void* _memcpy(void* dest,const void* src,size_t count)
{
    assert((dest != NULL) && (src != NULL));
    assert(count > 0);
 
    char* psrc = (char*)src;
    char* pdest = (char*)dest;
    while(count --)
        *pdest++ = *psrc++;
 
    return dest;
}
int main()
{
	int x;
	char strSrc[] = "Hello World ! Fighting!";
	char strDest[20];
	cout << "please enter x" << endl;
	cin >> x;
	_memcpy(strDest, strSrc, x);
	strDest[x] = '\0';
	cout << "strDest:" << strDest << endl;
    return 0;
}

区别

#include<iostream>
using namespace std;
int main()
{
 int a[10];
 for(int i=0;i<10;i++)
  a[i]=i;
 memcpy(&a[4],a,sizeof(int)*6);
 for(i=0;i<10;i++)
  cout<<a[i]<<endl;
}

很简单的小程序！不过已经足以达到我的目的了：）将上面代码gcc之后再运行，结果为：0 1 2 3 0 
1 2 3 0 1 。
再把第13行改成：memmove(&a[4], a, sizeof(int)*6)，重新gcc再运行，结果为：0 1 2 3 0 1 2 
3 4 5 ！
呵呵，两者的区别出现了。不过其实这样还不够，继续修改13行： memmove(a,&a[4],sizeof(int)*6) //也就是将源、目的置换一下而已
重新gcc编译再运行，结果为：4 5 6 7 8 9 6 7 8 9 。
还不够，继续修改13行为： memcpy(a, &a[4], sizeof(int)*6); gcc并运行，结果仍为： 4 5 6 7 8 9 6 7 8 9 ！
至此真相已经大白了。对比上面四个结果，不难得出以下结论：
1. 当 src 和 dest 所指内存区有重叠时，memmove 相对 memcpy 能提供保证：保证能将 src 所指
内存区的前 n 个字节正确的拷贝到 dest 所指内存中；
2. 当 src 地址比 dest 地址低时，两者结果一样。
换句话说，memmove 与 memcpy 的区别仅仅体现在 dest 的头部和 src 的尾部有重叠的情况下；

memcpy
memcpy是把source指向的对象中的n个字符拷贝到destin所指向的对象中，
返回指向结果对象的指针。 
memmove也是把source指向的对象中的n个字符拷贝到destin所指向的对象中，
但过程就好象是先把source所指向的对象拷贝到临时数组中，
然后在从临时数组拷贝到destin所指的对象中，返回指向结果对象的指针。 
但要注意，除memmove之外的字符串操作函数在拷贝同一个字符串中的字符时，其结果是不确定的。
也就是说，memmove可以把自己的一部分拷贝给自己的另一部分。