#include <stdio.h>
#include <string.h>
int main()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  int arr2[] = { 9,9,9,9,9 };
  memcpy(arr1, arr2, sizeof(int) * (sizeof(arr2) / sizeof(arr2[0])));
  // sizeof(int) * (sizeof(arr2) / sizeof(arr2[0])) arr2的总字节个数；
  for (int i = 0; i < sizeof(arr1) / sizeof(arr1[0]); i++)
  {
    printf("%d ", arr1[i]);
  }
  return 0;
}

#include <stdio.h>
#include <string.h>
int main()
{
  char arr1[] = "xxxxxxxxxx";
  char arr2[] = "abcdef";
  // 这里拷贝6个字节，注意最好拷贝的时候不要把\0弄没了，不然打印会出错
  printf("%s\n", (char*)memcpy(arr1, arr2, 6));
  // 因为返回的是 void* 所以最好强转一下 
  return 0;
}

#include <stdio.h>
#include <assert.h>
void* my_memcpy(void* dest, const void* src, size_t num)
{
  assert(dest && src);
  // 先保存目的地的开头地址，以便于返回
  void* ret = dest;
  while (num--) // 当num为0拷贝字节数已够，拷贝结束
  {
    // 强转成char*的指针，因为这样，才是一个字节一个字节的拷贝
    *(char*)dest = *(char*)src;
    // 强转成char*指针++向后走跳过一个字节，为下一次的字节拷贝做准备；
    ++(char*)dest;
    ++(char*)src;
  }
  return ret;
}
int main()
{
  int a1[] = { 1,2,3,4,5,6,7,8,9,10 };
  int a2[] = { 9,9,9,9,9 };
  my_memcpy(a1, a2, 20);
  // 20:a2的总字节数
  for (int i = 0; i < sizeof(a1) / sizeof(a1[0]); ++i)
  {
    printf("%d ", a1[i]);
  }
  return 0;
}

#include <stdio.h>
#include <string.h>
int main()
{
  int a1[] = { 1,2,3,4,5,6,7,8,9 };
  int a2[] = { 6,6,6,6,6 };
  memmove(a1, a2, 20);
  for (int i = 0; i < sizeof(a1) / sizeof(a1[0]); ++i)
  {
    printf("%d ", a1[i]);
  }
  return 0;
}

#include <stdio.h>
#include <string.h>
int main()
{
  int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
  memmove(arr + 2, arr, 20);
  // 将 1 2 3 4 5 拷贝到 3 4 5 6 7 上面去
  for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i)
  {
    printf("%d ", arr[i]);
  }
  return 0;
}

#include <stdio.h>
#include <assert.h>
void* my_memmove(void* dest, const void* src, size_t num)
{
  assert(dest && src);
  void* ret = dest;
  // 落在第三区间总会进一种拷贝方式
  if (src < dest)
  {
    // 从后往前
    while (num--) // 因为判断后 num-- 一次，第一次进来如果num开始为20，
    {             // 进来后等于19找到最后一个字节拷贝
      // 随着num--，拷贝的字节从后往前依次跳一个字节
      *((char*)dest + num) = *((char*)src + num);
    }
  }
  else
  {
    // 从前往后
    while (num--)
    {
      // 这里跟上面的memcpy的自我实现差不多，但是memcpy也可以以从后往前的方式实现
      *(char*)dest = *(char*)src;
      ++(char*)dest;
      ++(char*)src;
    }
  }
  return ret;
}
int main()
{
  int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
  my_memmove(arr + 2, arr, 20);
  for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i)
  {
    printf("%d ", arr[i]);
  }
  return 0;
}

#include <stdio.h>
#include <string.h>
int main()
{
  int a1[] = { 1,2,3,4,5,6,7,8 };
  int a2[] = { 1,2 };
  printf("%d\n", memcmp(a1, a2, 8));
  // 8个字节，比较前两个元素
  return 0;
}

#include <stdio.h>
#include <string.h>
int main()
{
  int a1[] = { 1,2,3,4,5,6,7,8 };
  int a2[] = { 1,2,5 };
  printf("%d\n", memcmp(a1, a2, 12));
  // 12个字节，比较前三个元素
  return 0;
}

#include <stdio.h>
#include <assert.h>
int my_memcmp(const void* ptr1, const void* ptr2, size_t num)
{
  assert(ptr1 && ptr2);
    // 比对次数--
  while (num--)
  {
      // 如果有不相同的字节，这里为真，进去返回差值
    if (*(char*)ptr1 - *(char*)ptr2)
      return *(char*)ptr1 - *(char*)ptr2;
    ++(char*)ptr1;
    ++(char*)ptr2;
  }
    // 比对完了没有找到不相同的字节说明都相同，返回0；
  return 0;
}
int main()
{
  int a1[] = { 1,2,3,4,5,6,7,8 };
  int a2[] = { 1,2,5 };
  printf("%d\n", my_memcmp(a1, a2, 8));
  // 12个字节，比较前三个元素
  return 0;
}

#include <stdio.h>
#include <string.h>
int main()
{
  char arr[] = "xxxxxxxxxx";
  printf("%s\n", (char*)memset(arr, 'y', 5));
  return 0;
}

#include <stdio.h>
#include <string.h>
int main()
{
  int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
  printf("%s\n", (char*)memset(arr, 1, 40));
  // 40表示整个arr的字节个数
  return 0;
}

#include <stdio.h>
#include <assert.h>
void* my_memset(void* ptr, int value, size_t num)
{
  assert(ptr);
  void* ret = ptr;
  while (num--)
  {
    *(char*)ptr = value;
    ++(char*)ptr;
  }
  return ret;
}
int main()
{
  char a[] = "abcdefgh";
  printf("%s\n", (char*)my_memset(a, '@', 5));
  return 0;
}