对于内存操作函数，一般情况下有四种：
memcpy :内存拷贝
memmove ：内存移动
memcmp ：内存比较
memset ：内存设置
上面的四种内存操作函数，在笔者后续的文章中都会讲到，但是在此篇文章中，由于笔者的懒虫原因！所以，暂时先只讲解memcpy内存拷贝函数！！若对其他的三个函数有兴趣的读者，请参考一下笔者后续文章！！
对于memcpy内存拷贝函数的使用语法为：
void * memcpy ( void * destination, const void * source, size_t num )
在上面的语法中：destination是指：目标空间，source是指：源头，num是指要拷贝的多少个字节
因此，总体的意思为：将源头的num个字节个数据拷贝到目标空间里面！！
1.在整型数组中的使用情况为：
#include <stdio.h>
#include <string.h>
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = { 0 };
memcpy(arr2, arr, 20);
//在这里20，是指要拷贝的字节数！！一个int 类型所占4个字节
//20个字节，是指5个整型！
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr2[i]);
}
return 0;
}
在上述的代码中：首先定义了一个： int arr[] = { 1,2,3,4,5,6,7,8,9,10 }; 并将其拷贝到一个arr2[]的数组中，但是arr2[]这个数组进行了初始化：int arr2[10] = { 0 }; 所以能够很明显的根据结果观察出来该memcpy内存拷贝函数的使用情况！！
代码的运行结果为：
2.在浮点型数组中的使用情况为：
#include <stdio.h>
#include <string.h>
int main()
{
float arr1[] = { 1.0f,2.0f,3.0f,4.0f };
float arr2[4] = { 0.0 };
memcpy(arr2, arr1, 8);
//在这里8，是指要拷贝的字节数！！一个float 类型所占4个字节
//8个字节，是指2个浮点型！
int i = 0;
for (i = 0; i < 4; i++)
{
printf("%.3f ", arr2[i]);
}
return 0;
}
上述代码的使用过程跟上面那个类似，在此，笔者就不再做过多的讲述！！请参考上面的解析内容就行！！
代码的运行结果为：
经过上面的内容，想必各位老铁也能清晰的认识了memcpy这个函数了！！下面笔者将带领大家进入memcpy函数的模拟实现部分！！请注意啦！压轴的部分来了！！
在整型数组中的模拟实现：
#include <stdio.h>
#include <string.h>
#include <assert.h>
void* my_memcpy(void* dest, void* src, size_t num)
{
void* ret = dest;
assert(dest);
assert(src);
while (num--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = { 0 };
my_memcpy(arr2, arr1, 20);
int i = 0;
for (i = 0; i<10;i++)
{
printf("%d ", arr2[i]);
}
return 0;
}
1.在memcpy的语法中，由于num是需要拷贝的字节数，所以在模拟实现的时候，一个字节一个字节的拷贝比较合适！！
2.assert(dest); assert(src); 断言部分！后面的代码中，涉及对指针dest 及src 的解引用操作！需要确保不为空指针！！
3.(char)dest = (char)src 在定义的时候，使用的是：void* my_memcpy(void* dest, void* src, size_t num) void * 类型的dest 与 src不能进行解引用操作，必须先强制类型转化为char*类型！！
但是为什么是char 类型呢？？主要的原因还是在于：对char类型的指针进行解引用，才能访问一个字节，从而实现num个字节的拷贝！！
4.对于：dest = (char*)dest + 1; src = (char*)src + 1; 这段代码部分，其实主要原因还是在于平常我们所熟悉的代码，在不同的编译器下，不一定能够正常的运行出来！！
就比如：这种写法：在不同的编译器下运行情况也是不一样的：
((char*)dest)++;
((char*)src)++;
5.对于最后的部分：return ret; 在这里返回值为：ret ，但是为什么不能返回：dest呢？？
原因在于：dest在while()循环中，走的已经不再是起始位置了！！
6.对于浮点型数组的写法，稍微该一点内容就行，在此，就不做过多的描述！
代码的运行结果为：
上面的内容就是本文主要讲解的部分！！
思考一下：对于数组：int arr[]={1,2,3,4,5,6,7,8,9,10};能不能将1，2，3，4，5拷贝到3，4，5，6，7的位置？？从而结果为：1，2，1，2，3，4，5，8，9，10呢？？？
这个答案是不能，但是为什么不可以呢？？这个就涉及到内存移动：memmove的模拟实现部分了！！
上面的问题，主要还是指：思考一下：对于数组：int arr[]={1,2,3,4,5,6,7,8,9,10};能不能将1，2，3，4，5拷贝到3，4，5，6，7的位置？？从而结果为：1，2，1，2，3，4，5，8，9，10呢？？？ 这个答案是不能，但是为什么不可以呢？？下面将是笔者的具体解析内容，请各位老铁仔细思考哟！！！
由于在CSDN进行描写不是很方便，所以下面是笔者在画图板上面的内容！
请大家仔细思考一下！！
由于在memcpy函数拷贝的时候，是按照字节来进行拷贝的！！所以，会进行一个一个int类型的拷贝，拷贝的数字将会覆盖原来的数字！所以，才会导致上面的结果！！请大家分析一下！就能得出上述结论！！
对于上述代码的实现过程为：
#include <stdio.h>
#include <string.h>
#include <assert.h>
void* my_memcpy(void* dest, void* src, size_t num)
{
void* ret = dest;
assert(dest);
assert(src);
while (num--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
my_memcpy(arr1 + 2, arr1, 20);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
当然，这个代码，还是借用了memcpy内存拷贝的模拟实现！！所以还是希望各位老铁能够欣赏一下笔者的博客！！
在上述代码里面：my_memcpy(arr1 + 2, arr1, 20); arr1是指数组的首元素！！arr1+2是：指向数组的第三个元素！！
经过上面的画图分析过程，想必代码的运行结果也是显而易见的！！
总结：当源头与目的地的空间有重合的部分，会被覆盖掉！！所以显得上面的代码，不是很合理！！
下面笔者来带领大家具体情况具体分析一下！！请仔细思考！
对于数组arr1[]={1,2,3,4,5,6,7,8,9,10}我们可以：从一下方面进行考虑：
1.将1，2，3，4，5放到3，4，5，6，7的位置 ，我们可以用从后往前放的方法来实现目地！！
第一步：将5放在7的位置，第二步：将4放在6的位置，第三步：将3放在5的位置……这样依次按照顺序来实现！！
2.但是：对于所有的部分都进行这种从后往前放的顺序，又不一定都对！ 就比如：将4，5，6，7，8放在1，2，3，4，5的位置处！
按照从后往前放的方式来进行思考的话：那么：第一步：将8放在5的位置，第二步：将7放在4的位置，第三步：将6放在3的位置，第四步：将5放在……（注意此时5的位置处，放置的不再是5了，已经被前面的8替代！！所以显得非常不合理！！）
所以对于这种的拷贝情况，我们应该这样思考：从前往后放！！
经过上面的两个案列，想必各位老铁也能看出来：复杂！！
总结：有时候需要从前往后拷贝！！
有时候需要从后往前拷贝！！
因此，笔者进行粗略的总结一下 ：
因此，对于memcpy函数的模拟实现的更加完整的代码为：
#include <stdio.h>
#include <string.h>
#include <assert.h>
void* my_memcpy(void* dest, void* src, size_t num)
{
void* ret = dest;
assert(dest);
assert(src);
if (dest < src)
{ //在这里：比较的是地址！！
while (num--)
{
//从前往后
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
}
else
{
while (num--)
{
*((char*)dest + num) = *((char*)src + num);
//从后往前
}
}
return ret;
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
my_memcpy(arr1 + 2, arr1, 20);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
上述代码的运行结果为：
其实，在C语言中，重叠部分的内存拷贝是交给：memmove函数实现的！！
因此对于memmove函数的模拟实现，便是将上面的代码，改改名字罢了！！在此，笔者就不再更改了！！
因此： memcpy只需要实现不重叠部分内存拷贝就可以了！
memmove是需要实现重叠部分内存拷贝的！！
