1.memcpy函数详解
- 模拟实现memcpy函数
2.memmove函数详解
- 模拟实现memmove函数
memset函数详解
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函数
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<src -->从前往后拷贝
当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进制转换成十进制，与上图结果相符。
