一：memcpy的使用和模拟
memcpy使用时需要包含的头文件为#include<string.h>
void* memcpy(void* destination,const void* source,size_t num) - 函数memcpy从source的位置开始向后复制num个字节的数据到destination指向的内存位置（特别注意的是这里拷贝的单位是字节）
- 这个函数在遇到 ‘\0’ 的时候并不会停下来
- 如果source和destination有任何的重叠，拷贝的结果都是不可预知的
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[20] = { 0 };
//将arr1数组中前5个元素(20个字节)的内容拷贝放置在arr2数组中
memcpy(arr2, arr1, 20);
for (int i = 0; i < 20; i++)
{
printf("%d ", arr2[i]);
}
return 0;
}运行结果：
代码解析：
这个代码的主要作用是将数组arr1中前5个元素（一个int 即4个字节，所以5个元素相当于20个字节）拷贝到数组arr2中，然后我们用一个for循环将数组arr2中的20个元素进行打印
二：memcpy函数的模拟实现
//memcpy拷贝结束后返回目标空间的起始地址
//memcpy的模拟实现
void* my_memcpy(void* dest, void* src, size_t num)
{
assert(src && dest);
void* ret = dest;
while (num--)
{
*((char*)dest) = *((char*)src);
((char*)dest)++;
((char*)src)++;
}
return ret;
}
int main()
{
int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
//将数组arr1中的前5个元素拷贝至arr2中
//1 2 3 4 5
int arr2[20] = { 0 };
//1 2 3 4 5 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
my_memcpy(arr2, arr1, 20);
int i = 0;
//将数组arr2中的元素打印
for (i = 0; i < 20; i++)
{
printf("%d ", arr2[i]);
}
return 0;
}代码结果：
代码讲解：
模拟实现memcpy，memcpy拷贝结束后会返回目标空间的起始地址
定义两个指针和两个数组，将源头数组中4个元素（即20个字节）的内容拷贝至目标空间dest数组中，由于我们这里的memcpy函数针对的是内存块，所以memcpy不仅可以实现对int类型数据的拷贝，还可以拷贝char类型的数据。因此我们在这里定义的指针类型为void类型，返回类型为void类型的指针（void类型指针可以接受各种类型的指针类型），但需要注意我们不能直接对void类型的指针实现解引用。
需要注意不能直接src++或者dest++来达到指针向后移动的功能，我们需要将src和dest强制类型转换为具体类型例如char，int类型，但是由于我们是一个字节一个字节的将数组arr1中的前5个数据内容拷贝至arr2中的，如果我们选择强制类型转换成int类型有一些情况下我们可能无法使用。例如如果我们只需要将arr1中的17个字节的内容拷贝至目标空间arr2中的时候如果我们使用强制转换成int类型就无法实现。所以我们需要强制转换成char类型，即 ((*char) src)++和 ((*char) dest)++
由于源头内存不能被修改，所以可以在src前面加上const修饰
另外特别需要注意的是：
由于memcpy函数调用结束后会返回目标空间的起始地址，即指针dest，但是dest在代码中会别使用起始地址已经发生改变，所以一开始的时候我们可以先定义一个指针变量来存放dest的起始地址
小比较：memcpy函数主要考虑的是将一个数组中的元素拷贝至另一个数组中，如果将一个数组中的内容拷贝至同一个数组中拷贝的结果是未知的。例如：将arr1数组中1 2 3 4 5 拷贝至3 4 5 6 7 的位置，由于拷贝的内存空间发生重叠，此时应当使用memmove函数来实现。
三：memmove的使用
void* memmove(void* dest,void* src,size_t num)- 和memcpy的差别就是memmove函数处理的源内存块和目标内存空间可以重叠
- 如果源空间和目标空间发生重叠，就得使用memmove函数处理
int main()
{
int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
memmove(arr1 + 2, arr1, 20);
for (int i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
运行结果：
四：memmove函数的模拟实现
情况1：将数组arr1中的数据1 2 3 4 5 拷贝至数组arr + 2（即数据3的位置） 的位置，即将数组arr1中的数据3 4 5 6 7 改成1 2 3 4 5 ，需要从后向前拷贝数组arr1的数据，即先将数据5拷贝至7的位置，再将数据4拷贝至6的位置，以此类推，最后将数据1拷贝至3的位置。这是因为如果直接将数据1 2 3 4 5拷贝至3 4 5 6 7的位置会导致数据被覆盖，无法实现要求，如下图所示：
正确拷贝方式如下图：
情况2：
将数组arr1中的数据3 4 5 6 7 拷贝至数组arr1中1 2 3 4 5 的位置，即将数组arr1中的数据1 2 3 4 5改成3 4 5 6 7。在这里我们需要从前向后拷贝数组arr1中的数据，即先将数据3拷贝至1的位置，再将数据4拷贝至2的位置以此类推，最后将数据7拷贝至5的位置，那么数组arr1最终会变成3 4 5 6 7 6 7 8 9 10。拷贝过程如下图所示：
运行结果1：
执行结果2：
小总结：
memmove函数拷贝过程共有3中情况：
第一种情况为：dest < src如下图：
在这种情况下：需要将src中的数据从后向前拷贝至目标空间
第二种情况为dest > src如下图：
在这种情况下：需要将src中的数据从前向后拷贝至目标空间
第三种情况为第十二条和src没有重叠空间如下图：
在这种情况下:即可以将src中的数据从前向后拷贝至目标空间，也可以从后向前将数据拷贝至目标空间
为了方便我们将dest< src分成一种情况，dest > src分成一种情况。
模拟代码：
#include<stdio.h>
#include<string.h>
#include<assert.h>
void* memmove(void* dest, const void* src, size_t num)
{
assert(dest && src);
void* ret = dest;
if (dest < src)
{
//src从前向后拷贝
while (num--)
{
*((char*)dest) = *((char*)src);
((char*)dest)--;
((char*)src)++;
}
}
else
{
//src从后向前拷贝
while (num--)
{
*((char*)dest + num) = *((char*)src + num);
}
}
return ret;
}
//memmove的使用
int main()
{
int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
memmove(arr1 + 2, arr1, 20);
for (int i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
五：memset函数的使用
void* memset(void* ptr,int value,size_t num)注释：ptr指的是指向要被修改的指针，value指的是要被修改成的内容，num指的是要被修改的个数。
注意：memset是用来设置内存的，将内存中的值以字节为单位设置成想要的内容，以字节为单位就代表着如果我们要修改的内容为int类型可能结果与我们预想的不一样，如下例代码：
#include<stdio.h>
#include<string.h>
//memset的使用
int main()
{
int arr1[5] = { 1,2,3,4,5 };
memset(arr1, 1, 20);//以字节为单位将arr1中的5个元素该成1
for (int i = 0; i < 5; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}运行结果：
内存情况：
由此可知：由于每个字节的是01，所以最后的结果是16843009而不是1。
六：memcpy函数的使用
int memcpy(const void* ptr1,const void* ptr2,size_t num)功能：
- 比较从ptr1和ptr2指针指向的位置开始向后的num个字节的内容
- 返回值如下：
如果ptr1比较的内容 < ptr2比较的内容，返回 <0的数 ；
如果ptr1比较的内容 = ptr2比较的内容，返回 0 ；
如果ptr1比较的内容 > ptr2比较的内容，返回 >0 的数；
代码：
#include<stdio.h>
#include<string.h>
//memcpy的使用
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8 };
int arr2[] = { 1,2,3,4,8,8,8,8 };
int ret = memcmp(arr1, arr2, 16);//比较arr1和arr2中前16个字节的内容（即4 个元素）
printf("%d\n", ret);
return 0;
}运行结果：
代码：
#include<stdio.h>
#include<string.h>
//memcpy的使用
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8 };
int arr2[] = { 1,2,3,4,8,8,8,8 };
int ret = memcmp(arr1, arr2, 20);//比较arr1和arr2中前20个字节的内容（即5个元素）
printf("%d\n", ret);
return 0;
}运行结果：
