模拟实现memcpy，memmove

学习一个函数的最好方法其实使用自己了解的知识看看是否能实现它，今天实现memcpy和memmove这两个内存操作函数

1. memcpy函数
2. memmove函数

memcpy的格式和规则

void * memcpy ( void * destination, const void * source, size_t num );
函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
这个函数在遇到 '\0' 的时候并不会停下来。
如果source和destination有任何的重叠，复制的结果都是未定义的。

void * memcpy ( void * dst, const void * src, size_t count)
{
    void * ret = dst;
    assert(dst);
     assert(src);
    while (count--) 
   {
        *(char *)dst = *(char *)src;
        dst = (char *)dst + 1;
        src = (char *)src + 1;
   }
    return(ret);
}

注意：因为destination和source的类型是void*，在使用时需要强制类型转换称自己需要的类型

以上的代码是我们自己实现memcpy的成果，当我们把参数传给函数时，因为怕存在野指针就用断言来确认是否可行，接着while循环内就是主要的实现过程。

然而当目的地的内存和源头的内存中有重合的空间时，使用memcpy往往不能得到正确的结果

例如当上述代码的dst=src+2，我们本意是想从dst的地址开始复制num个字节，但因为是一个内存空间，当程序的运行进行时，原本的数据已经被覆盖，这就是弊端。

所以接下来这个函数可以用来解决这个问题。

memmove的格式和规则

void * memmove ( void * destination, const void * source, size_t num );

和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用memmove函数处理。

其实可以认为memmove是至臻版的memcpy

void * memmove ( void * dst, const void * src, size_t count)
{
    void * ret = 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(ret);
}

在进行编码的时候，既然memcpy无法解决它自身的弊端，我们不能入宝山而空返，那就换一个角度，从背后偷袭。

既然memcpy是从前往后的顺序进行复制，那我们就设计从后往前的顺序

 我们在假设的情况下，发现如图在一组数据中可以有从前往后，也可以从后往前，这主要取决于目的地空间与源空间的关系

dst <= src || (char *)dst >= ((char *)src + count

为什么强制转换成char*类型呢

是因为count代表的是字节数，从字节的层面来进行复制，char*的单位也是1个字节

除了顺序有颠倒，其他和memcpy并无区别，赶紧试一试吧