内存拷贝的实现，重写memcpy

#include <iostream>

using namespace std;

void  *mymemcpy(void *dest, const void *src, size_t count)

 {

        assert((src != NULL)&&(dest != NULL));

        char *tmp,*s;

        if(dest <= src)

        {

               tmp = (char *) dest;

               s = (char *) src;

               while(count--)

                      *tmp++ = *s++;

        }

        else {

               tmp = (char *) dest + count;

               s = (char *) src + count;

         while(count--)

             *tmp-- = *s--;

}

        return dest;

 }

int main(int argc, char* argv[])

{

    char arr2[]="2xoidfsflsdfsa";

    int len = sizeof(arr2)/sizeof(char);

    cout << len << '\n';

    char arr1[len];

    mymemcpy(arr1,arr2,len);

    for(char &x : arr1)

        cout << x;

    cout << '\n';

    return 0;

}

标准库也提供了地址重叠时的内存拷贝函数：memmove()，那么为什么还要考虑重写memcpy()函数呢?因为memmove()函数的实现效率问题，该函数把源字符串拷贝到临时buf里，然后再从临时buf里写到目的地址，增加了一次不必要的开销。

可以看到memcpy对于地址重叠（overlap）是未定义的

#include <iostream>
using namespace std;
void *Memcpy(void *dst,const void *src,size_t size)
{
    char *pdst=(char *)dst;
    char *psrc=(char *)src;
    
    if(dst==NULL || src==NULL)
        return NULL;
       //如果src和dst有重叠，则从后往前进行复制
    if((src<dst) &&(char *)src+size>(char *)dst)
    {
        pdst=(char *)dst+size-1;
        psrc=(char *)src+size-1;
        
        while(size--)
        {
            *pdst--=*psrc--;
        }
    }
    else//否则正常复制就好了
    {
        pdst=(char *)dst;
        psrc=(char *)src;
        
        while(size--)
        {
            *pdst--=*psrc--;
        }
    }
    return dst;
}
int main()
{
    char buff[100]="abcdefghijk";
    Memcpy(buff+2, buff, 5);
    cout<<buff<<endl;
}


//https://blog.csdn.net/weixin_42226134/article/details/104878232