memcpy函数

了解一个函数，就查询该函数的相关信息

memcpy函数在库中的声明如下

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

memcpy函数是将源头的字符串拷贝num个字节的数据到目标字符串，并返回一个void*的指针，也就是返回目标空间的首地址。

它的含义是：

Copy block of memory

我们知道，strcpy函数是拷贝字符串的，但是它并不能拷贝例如整型，结构体之类的东西，strcpy有一定的局限性，memcpy函数可以说涵盖了所有类型数据的拷贝。

下面直接看一个例子：

int main()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  int arr2[10] = { 0 };
  memcpy(arr2, arr1+2, sizeof(int)*5);
  //可以拷任意位置的数据，任意字节个数
  for (int i = 0; i < 5; i++)
  {
    printf("%d\n", arr2[i]);
  }
  return 0;
}

在上面的例子中，memcpy是将arr1+2处开始的20个字节拷贝到arr2中，即拷贝3，4，5，6，7

我们可以看一下结果：

既然是一个个字节地拷贝，我们在模拟实现的时候，应该考虑到void的指针应该是转换成char ，才能够满足每个字节地拷贝。

memcpy函数模拟实现

上面说到，memcpy函数是一个个字节地拷贝，拷贝num个字节，我们模拟实现的时候，应该按照库函数的声明来模拟实现。

来看上图，将src中的每一个字节的数据都拷贝到dest中，最后返回dest的首地址，就完成了。

void* my_memcpy(void* dest, const void* src, size_t num)
{
  assert(dest&&src);
  void* ret = dest;
  while (num--)
  {
    *(char*)dest = *(char*)src;
    //dest = (char*)dest + 1;
    //src = (char*)src + 1;
    ++(char*)dest;
    ++(char*)src;
    /*(char*)dest++;
    (char*)src++;*/  // error，先++，再强转，void*指针无法++
    //((char*)dest)++;
    //((char*)src)++;
  }
  return ret;
}
int main()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  int arr2[10] = { 0 };
  my_memcpy(arr2, arr1+2, sizeof(int)*5);
  for (int i = 0; i < 5; i++)
  {
    printf("%d\n", arr2[i]);
  }
}

首先应该断言，判断指针的有效性，既然库中的memcpy函数会返回目的地的首地址，所以应该设置一个void*的指针来保存该地址，因为在拷贝的过程中，目的地的地址会不断变化，在上面模拟实现的过程中，注释的几个代码都是可以实现的。

结果如上图所示：

不知道你是否想过一个问题，对于memcpy函数而言，假如我想要拷贝自己，假如把自己的3，4，5，6，7拷贝到1，2，3，4，5中，能不能实现呢？

就我现在模拟实现的函数而言，是无法实现的，因为在拷贝的过程中，自身的值会发生改变，也就变成了1 2 1 2 1 2 1 8 9 10

那么，针对这一问题，就有一个函数能够解决：memmove函数

(实际上，库里面的memcpy函数能够完全实现memmove函数的功能，可以说memcpy超额完成任务)

memmove函数

memmove函数其实是更有针对性地对于有重叠数据的拷贝而诞生的。

就像上面的例子，假如拷贝的数据有重叠，就需要用到memove函数。

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

函数声明与memcpy函数相同。

还是上面的例子，使用memmove能够完美实现拷贝重叠部分。

int main()
{
  int arr1[20] = { 1,2,3,4,5,6,7,8,9,10 };
  int arr2[10] = { 0 };
  mmemmove(arr1+2, arr1, sizeof(int) * 5);
  for (int i = 0; i < 10; i++)
  {
    printf("%d\n", arr1[i]);
  }

结果如下：

那么，memmove函数的工作原理到底是什么呢？

在上面的例子中，不管目标位置是否大于原位置，memcpy拷贝的时候都是从前往后拷贝，这才导致拷贝不成功，但是当我们从后往前拷贝呢？

可以看到，当dest的位置大于src位置时，从后往前拷贝是没有问题的，那么假如dest的位置小于src的位置呢？

是否还是一直从后往前拷贝？

一直从后往前拷贝过于绝对。

当dest的位置小于src的位置时，从前往后拷贝是合适的。

当dest>src，并且超出了src的范围呢？

就像这样，其实，这种情况已经是不重叠的情况了，也就是使用memcpy的方式处理，我们在拷贝的时候，必须保证目标空间足够大，所以不可能存在越界拷贝的情况。

所以在这第三种情况的时候，无论从前往后拷贝，还是从后往前拷贝，都是可以的。

我们不如从后往前拷贝，这样就使问题简单多了。

所以我们得出结论：

当dest从前往后拷贝
当dest>src，从后往前拷贝

图解如下：

下面就可以开始模拟实现了：

memmove函数模拟实现

有了上面的理解，模拟实现就好办了。

void* my_memmove(void* dest, const void* src,size_t num)
{
  assert(dest && src);
  void* ret = dest;
  if (dest < src)
  {
    // 前->后
    while (num--)
    {
      *(char*)dest = *(char*)src;
      ((char*)dest)++;
      ((char*)src)++;
    }
  }
  else // 后->前拷贝 
  {
    while (num--)
    {
      *((char*)dest + num) = *((char*)src + num); //首先要找到最后一个字节
        //不用count -1,进入循环时，count已经--了
    }
  }
  return ret;
}

memset函数

void * memset ( void * ptr, int value, size_t num );

该函数是一个设置函数，将指定的内存设置成指定的值。

什么意思呢？

举个例子：

int main()
{
  char arr[] = "hello world";
  memset(arr, 'x', 5);
  memset(arr+6, 'y', 5);
  printf("%s\n", arr);
  return 0;
}

该函数的意思是：将arr中的前 5 个字节设置成x，将arr的第6个字节开始的后五个字节设置成y。

注意：单位是字节，也就是一个一个字节地设置。

看下面的例子：

int main()
{
  int arr[10] = { 0 };
  memset(arr, 1, 40);
  return 0;
}

这样设置，会不会让arr中的10个元素都设置成1呢？

不会。

注意：单位是字节，是一个个字节地设置

将16进制转换成十进制，与上图结果相符。