1.memcpy
与字符串函数 strcpy 类似，也是进行拷贝。但是需要注意的是，strcpy 是针对字符串进行拷贝，而 memcpy 是针对内存进行拷贝。
如何理解呢？strcpy 进行拷贝的时候，只能一个字节一个字节的拷贝，但要实现 整型、浮点型等数据类型拷贝的时候，就不得不用到 memcpy 了。
我们观察 strcpy 的函数声明：
char * strcpy ( char * destination, const char * source );
再观察 memcpy 的函数声明：
void * memcpy ( void * destination, const void * source, size_t num );
可以看到 strcpy 的局限在于只能接收 字符型 的指针，但 memcpy 对于类型可以在函数内部实现自定义。
我们浏览 cplusplus 对参数作出的解释：
现在我们要研究如何使用：
#include <stdio.h>
#include <string.h>
int main()
{
int dest[10] = { 0 };
int src[10] = { 1,2,3,4,5,6,7,8,9,10 };
memcpy(dest, src, 20);//拷贝 20 个字节
return 0;
}我们从 src 数组中，拷贝 20 个字节的数据放到 dest 数组中。那么我们通过 调试—窗口—监视 来观察 dest 数组中的变化：
未经 memcpy 前：
经 memcpy 后：
可以直观地看到， dest 数组中前 20 个字节的内容发生了改变。
使用起来倒是不复杂，那我们能不能用自己的代码去模拟实现一个 memcpy 函数？
#include <stdio.h>
void* AnalogMemcpy(void* dest, const void* src, unsigned int num)
{
void* start = dest;//定义一个记录 dest 初始地址的指针
while (num--)//一个字节一个字节拷贝
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return start;//返回此指针
}
int main()
{
int dest[10] = { 0 };
int src[10] = { 1,2,3,4,5,6,7,8,9,10 };
AnalogMemcpy(dest, src, 20);
return 0;
}我们的实现思路非常简单，因为官方给出第三个参数的定义是：要复制的字节数。那我们顺水推舟一个字节一个字节的拷贝。
但是到这里，可能会存在这样一个问题： char 类型是一个字节，我们使用 memcpy 时也是一个字节一个字节的拷贝，那为什么 strcpy 不能拷贝整型？
在我们自己模拟实现 strcpy 的时候，拷贝的停止条件是什么？是 src 字符串碰到 '\0' 。默认我们的设备是小端存储模式，那么我们使用 strcpy 进行拷贝的时候就会出现这种情况：
现在我们使用模拟实现的 memcpy 函数来执行这段代码：
#include <stdio.h>
void* AnalogMemcpy(void* dest, const void* src, unsigned int num)
{
void* start = dest;//定义一个记录 dest 初始地址的指针
while (num--)//一个字节一个字节拷贝
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return start;//返回此指针
}
int main()
{
int dest[10] = { 1,2,3,4,5,6,7,8,9,10 };
AnalogMemcpy(dest + 3, dest, 20);
return 0;
}这段代码的意思是这样的：
但事实上真正的结果是：
这该如何解释呢？其实不难：
那么我们暂且定下一个结论：
memcpy 只能处理空间不重叠的数据拷贝。
2.memmove
这个函数与 memcpy 的功能相同，都是进行数据拷贝。但是不同的点是：memmove 是用来处理空间重叠的数据拷贝的。
这是 memmove 的函数声明：
void * memmove ( void * destination, const void * source, size_t num );
既然是处理空间重叠的情况，那我们直接对上一个代码进行处理：
可以看到， memmove 符合我们的预期实现了效果。
我们现在来挑战一下如何模拟实现一个 memmove 函数：
#include <stdio.h>
void* AnalogMemmove(void* dest, const void* src, unsigned int num)
{
void* start = dest;//定义一个记录 dest 初始地址的指针
if (src < dest)//如果 src 在 dst 的左边
{
while (num--)
{
*((char*)dest + num) = *((char*)src + num);
}
}
else
{
while (num--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
}
return start;//返回这个指针
}
int main()
{
int dest[10] = { 1,2,3,4,5,6,7,8,9,10 };
AnalogMemmove(dest + 3, dest, 20);
return 0;
}乍一看，这个代码比较复杂，事实上，只有两种情况。
我们来分析一下：
但是！这里要注意了，上面使使用自己模拟的 memcpy 不能实现空间重叠拷贝的，但库函数原装的 memcpy 能够实现空间重叠拷贝吗？
我们来看库函数 memcpy 能否实现空间重叠拷贝：
#include <stdio.h>
#include <string.h>
int main()
{
int dest[10] = { 1,2,3,4,5,6,7,8,9,10 };
memcpy(dest + 3, dest, 20);
return 0;
}
这就奇了怪了！既然库函数 memcpy 能够实现空间重叠的拷贝，那还需要 memmove 做什么？
事实上，对于我使用的 Visual Studio 2022 这款编译器来说，memcpy 是可以实现空间重复拷贝的。也就是说可能在其他的编译器上实现不了空间重叠拷贝，但 Visual Studio 2022 这款编译器赋予了 memcpy 这项功能。
3.memcmp
与 strcmp 类似的，这个函数也是进行比较的函数，我们观察一下它的函数声明：
int memcmp ( const void * ptr1, const void * ptr2, size_t num );
那么对于这些参数以及返回值的解释是：
因为我们学习过 strcmp ，那我们现在直接使用它：
#include <stdio.h>
#include <string.h>
int main()
{
int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = { 1,2,3,3,4,5,6,7,8,9 };
int ret=memcmp(arr1, arr2, 20);
if (ret > 0)
printf("arr1 > arr2\n");
else if (ret < 0)
printf("arr1 < arr2\n");
else
printf("arr1 == arr2\n");
return 0;
}
与 strcmp 的原理是一致的，这里就不赘述了。
4.memset
直译过来就是内存设置。事实上也是这么回事。
观察它的函数声明：void * memset ( void * ptr, int value, size_t num );
它的作用是以及参数的意义：
说白了就是：你需要提供一个指针，这个指针指向的要被填充的内存。然后提供一个值，这个值决定了每个字节要被填充为什么内容。最后提供一个数，这个数指的是你要填充多少个字节。
我们写一个例子：
#include <stdio.h>
#include <string.h>
int main()
{
int arr[10] = { 0 };
memset(arr, 1, 4);
return 0;
}
这就奇了怪了，我们不是设置四个字节为 1 吗？ 千万不要么想。我们上面强调过了，这个函数是对每个字节填充。
我们分析一下我们写的例子：
