内存操作函数

内存操作函数概念及使用：

memcpy

• 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
• 这个函数在遇到 ‘\0’ 的时候并不会停下来。
• 如果source和destination有任何的重叠，复制的结果都是未定义的。

#include<stdio.h>
#include<string.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10];
	memcpy(arr2, arr, 40);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

从上面运行的代码中可以看出，memcpy函数和strcpy函数效果基本相同，区别在于memcpy函数是将arr1数组中的数据拷贝到arr2数组中去。

如果我们想要将arr数组中的1 2 3 4 5覆盖掉arr数组中的3 4 5 6 7，打印出来是：1 2 1 2 3 4 5 8 9 10；memcpy函数可以实现吗？

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

为什么这里的memcpy不可以呢？

如果source和destination有任何的重叠，复制的结果都是未定义的。
参考上图：
我们将空间1处的值（1）拷贝到空间3处，空间3处的值变为了1；
空间2处的值拷贝到空间4处后，空间4处的值变为了2；
将空间3处的值拷贝到空间5处，空间5处的值变为了1；
所以打印出来就是1 2 1 2 1 2 1 8 9 10。

memmove

• 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
• 如果源空间和目标空间出现重叠，就得使用memmove函数处理。

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

而我们的memmove函数就可以做到啦。

memcmp

• 比较从ptr1和ptr2指针开始的num个字节
• 返回值如下：
  
  如果ptr1的值小于ptr2中的值，返回一个<0的数；
  如果ptr1的值和ptr2的值相同，返回0；
  如果ptr1的值大于ptr2的值，返回一个>0的值。

#include<stdio.h>
#include<string.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[] = { 1,2,3, 5 };
	printf("%d",memcmp(arr2, arr, 21));
	return 0;
}

在vs中内存是按小端进行存放的

• 在21个字节中进行对比，前20个字节都相同
• 当第21字节时：
• arr数组是06，arr2数组是00，arr数组大于arr2数组，所以返回一个正数；当走完21个字节两个数组都相等时，返回值为0
• 当走完21个字节，arr2数组小于arr，返回值是负数。

memset

#include<stdio.h>
#include<string.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("%d",memset( arr,1,8));
	return 0;
}

我们向memset函数传递了arr数组的首元素地址，向后走8个字节，每个字节都设置为1。

模拟实现内存函数

模拟实现memcpy：

从图中得知，memcpy函数返回类型是void*，有三个接收参数，类型分别是void*，void*，size_t
void*：接收任何类型的指针，无需强制类型转换，但是用时一定要将void*类型的指针变量强制类型转换为你想要的指针类型。
size_t：无符号正数,单位是字节

• 因为我们是模拟实现memcpy函数，所以我将memcpy返回类型和接受类型都设计的和库函数相同。
• 形参部分使用void是因为memcpy可以拷贝不同类型的数据（整型、字符、结构体），使用void要注意强转，因为size_t是一个字节一个字节向后走的，所以我们要让destination和source也一个字节一个字节向后走，所以要将destination和source强制类型转换为char*类型。
• 我们只是将(source)arr2数组中每一个字节的值拷贝给destination（arr1），所以不需要对源空间进行修改，使用const是为了防止源空间（destination/arr2）存放的数据被修改。

#include<stdio.h>
#include<assert.h>
void* my_memcpy(void* arr1, const void* arr2, size_t num)
{
	assert(arr1 && arr2);
	void* p = arr1;
	while (num--)
	{
		*((char*)arr1) = *((char*)arr2);
		arr1 = (char*)arr1 + 1;
		arr2 = (char*)arr2 + 1;
	}
	return p;
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10];
	my_memcpy(arr+2, arr, 20);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

模拟实现memmove

memmove函数的返回值类型和形参部分参数类型和memcmp函数的函数返回类型和形参部分参数类型完全相同
上文说了memove和memcpy两个函数之间的差别在于memcpy函数不可以对重叠的源空间和目标空间进行操作
而memmove函数可以对重叠的源空间和目标空间进行操作。
那么到底为什么memmove函数可以对重叠源空间和目标空间进行操作呢？

上文中已经说明了memcpy函数为什么和我们想象的结果不同，就是因为拷贝方法只有一种，按照给定顺序进行拷贝；
而memmove函函数可以进行拷贝重叠源空间和目标空间,是memmove会根据重叠部分进行判断，选择适合的方法进行执行。

• 假设我们当前源空间指向1处，目标空间指向3处
• 我们判断目标空间地址大于源空间地址，采用从源空间地址+num-1位置处开始拷贝，先将源空间地址+num-1处的值拷贝到目标空间地址+num-1处，再将num–，在进行循环操作，直到num==0；
• 如果源空间地址小于目标空间地址，就从前向后进行拷贝。

#include<string.h>
#include<stdio.h>
#include<assert.h>
void* my_memmove(void* arr1, const void* arr2, size_t num)
{
	assert(arr1 && arr2);
	void* p = arr2;
	if (arr1 > arr2)
	{
		while (num--)
		{
			*((char*)arr1 + num) = *((char*)arr2 + num);
		}
	}
	else
	{
		while (num--)
		{
			*((char*)arr1) = *((char*)arr2);
			arr1 = (char*)arr1 + 1;
			arr2 = (char*)arr2 + 1;
		}
	}
	return p;
}
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 < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

模拟实现memcmp

memcmp返回类型是int，形参部分参数类型为void*，void*，size_t，我们还是要和库函数保持一致

• 从prt1处和ptr2处一个字节一个字节进行对比，直到num==0

#include<stdio.h>
#include<assert.h>
int my_memcmp(const void* arr1, const void* arr2, size_t num)
{
	assert(arr1 && arr2);
	while (*((char*)arr1) == (*((char*)arr2)) && num--)
	{
		((char*)arr1)++;
		((char*)arr2)++;
	}
	return (*(char*)arr1)-(*(char*)arr2);
}
int main()
{
	int arr[] = { 1,2,3,4,5,6 };
	int arr2[] = { 1,2,9,4,5,7};
	printf("%d", my_memcmp(arr2, arr, 21));
	return 0;
}

模拟实现memset

• memset是将num个字节的值value赋值给ptr处

#include<stdio.h>
#include<assert.h>
void* my_memset(void* arr, int value, size_t num)
{
	char* p = arr;
	while (num--)
	{
		*(char*)arr = value;
		((char*)arr)++;
	}
	return p;
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("%d\n", my_memset(arr, 1, 4));
	return 0;
}

希望以上对您有所帮助！当然，如果文章出现错误，欢迎您在评论区或私信我指出哦~