内存函数（memcpy、memmove、memset、memcmp）

本文介绍: 因为 m em set 是以字节为单位工作的，所以这里会将 arr 的前5个字节都设置为 ‘x‘ 的ASCII值。需要注意的是，一个整数通常占用4个字节（这取决于系统和编译器），所以这里实际上比较的是两个数组的前4个整数以及第5个整数的部分字节。如果目标地址不小于源地址，说明移动方向是从后往前，因此从源地址的最后一个字节开始，逐个拷贝到目标地址的对应位置。函数开始时，先保存了原始的目标地址，以便最后返回。如果目标地址小于源地址，说明移动方向是从前往后，因此从源地址的每一个字节拷贝到目标地址，并逐渐向后移动。

一、memcpy的使用和实现

一、m e mcp y的使用和实现

m e mcp y 拷贝的就是不重叠的内存。

参数	dest i nat ion	source	num
解析	存储复制内容的目标空间	被拷贝数据源	拷贝字节数

void * m e mcp y ( void * dest i nat ion, const void * source, size _t num );

// me mcp y 可以拷贝任何类型的数据，因此使用 vo id* 作为参数类型 v o id* me mcpy(v o id* des ti nat ion, cons t v o id* sour ce, size _t num)

• 函数me mcpy从sour ce的位置开始向后复制num个字节的数据到des ti nat ion 指向的内存位置。

• 这个函数在遇到 ” 的时候并不会停下来。

• 如果sour ce和des t in a t ion有任何的重叠，复制的结果都是未定义的。

使用：

int main() { in t arr1[10] = { 1,2,3,4,5,6,7,8,9,10 }; in t arr2[10] = { 0 };

// 使用 me mcpy 将 arr1 中的 4,5,6,7,8 拷贝到 arr2 中

me mcpy(arr2, arr1 + 3, 5 * sizeof(int)); // 从 arr1 的第四个元素开始，拷贝 5 个 int 类型的数据到 ar r2 ；

fo r (int i = 0; i < 10; i++) { printf(“%d “, arr2[i]);

// 输出 arr2 的内容，预期结果：4 5 6 7 8 0 0 0 0 0 } ；

int main() { char arr1[10] = “heo bit“;

// 注意：字符串中间有一个 ”，但实际上 arr1 的内容是：’h‘, ‘e‘, ”, ‘o’, ‘ ‘, ‘b‘, ‘i‘, ‘t’, ” char arr2[10] = { 0 };

// 使用 memcpy 将 arr1 中的 “o bit” 拷贝到 arr2 中 memcpy(arr2, arr1 + 3, 5);

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0 };
	//将arr1中的1 2 3 4 5 拷贝到arr2中
	memcpy(arr2, arr1+3, 5 * sizeof(int));
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

int main()
{
	char arr1[10] = "heo bit";
	char arr2[10] = { 0 };
	//将arr1中的1 2 3 4 5 拷贝到arr2中
	memcpy(arr2, arr1 + 3, 5);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%c ", arr2[i]);
	}
	return 0;
}

模拟 实现：

void* my _memcpy(void* dest, void* src, size _t num)
{
// 保存目标地址的原始值，这样在函数结束时可以返回它。
void* ret = dest;
// 确保目标地址和源地址都不是NULL。如果是NULL，则assert会终止程序。
assert(dest && src);
// 循环，直到拷贝完所有字节。
while (num–)
{
// 从源地址拷贝一个字节到目标地址。
*(char*)dest = *(char*)src;
// 移动到下一个字节。
dest = (char*)de st + 1;
s rc = (char*)s rc + 1;
}
// 返回原始的目标地址。
return ret;
}
int main()
{
// 定义并初始化一个整数数组arr1。
int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
// 定义并初始化一个整数数组arr2，所有元素都为0。
int arr2[10] = { 0 };
// 使用自定义的my_memcpy函数，将arr1中的部分数据拷贝到arr2中。
// 从arr1的第4个元素开始，拷贝5个整数到arr2中。
//将arr1中的1 2 3 4 5 拷贝到arr2中
my_memcpy(arr2, arr1+3, 5 * sizeof(int));
}

void* my_memcpy(void* dest, void* src,size_t num)
{
	void* ret = dest;
	assert(dest &amp;&amp; src);
	while (num--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0 };
	//将arr1中的1 2 3 4 5 拷贝到arr2中
	my_memcpy(arr2, arr1+3, 5 * sizeof(int));
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

二、memm ove 使用和模拟 实现

memove 拷贝的就是重叠的内存。

void * memm ove ( void * destination, const void * source, size_t num );

返回值说明：返回指向dest的void *指针

参数说明：dest,src分别为目标串和源串的首地址。count为要移动的字节的个数

函数说明：memmove用于从src拷贝count个字节到dest，如果目标区域和源区域有重叠的话，memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中。

• 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。

• 如果源空间和目标空间出现重叠，就得使用memmove函数处理。

参数	des tination	source	num
解析	存储复制内容的目标空间	被拷贝数据源	拷贝字节数

模拟 实现：

2.1难点：

覆盖拷贝所在的问题

我们就要重点注意覆盖拷贝的问题，因为会导致未被拷贝的数值受到更改。

情况一：src在dest之前。

我们可以发现自src下标小端拷贝，就不会出现之前的未进行拷贝就被更改的情况。

情况二：dest在src之前。

我们可以发现自src下标大端拷贝，就不会出现之前的未进行拷贝就被更改的情况。

所以此时我们有了两种选择，按图示来说：

1、在7之前为，前——>后，在7之后，后——>前。

2、在3之前为，前——>后，在3之后，后——>前。

my_memmove函数是为了实现内存的移动功能，类似于C标准库中的memmove函数。

这个函数接收三个参数：目标地址、源地址以及需要移动的字节数。函数开始时，先保存了原始的目标地址，以便最后返回。

通过断言来确保目标地址和源地址都不是NULL。

接下来dest和src的关系，来确定移动的方向。

如果dest< src，说明移动方向是从前往后，因此从源地址的每一个字节拷贝到目标地址，并逐渐向后移动。

如果dest>=src，说明移动方向是从后往前，因此从源地址的最后一个字节开始，逐个拷贝到目标地址的对应位置。最后返回原始的目标地址。

main函数中使用my_memmove函数将arr1的前5个元素移动到从第3个位置开始的位置。这样，数组的前两个位置会被覆盖，而后面的元素则保持不变。

void* my_memmove(void* dest, void* src, size_t num)
{
	void* ret = dest;
	assert(dest &amp;&amp; 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[10] = { 1,2,3,4,5,6,7,8,9,10 };
	
	//将arr1中的1 2 3 4 5 拷贝到arr2中
	//my_memcpy(arr1 + 2, arr1, 5 * sizeof(int));
	my_memmove(arr1 + 2, arr1, 5 * sizeof(int));
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);//1 2 1 2 3 4 5 6 7 8 9 10
	}
	return 0;
}

memset的使用

memset – 内存设置
void * memset ( void * ptr, int value, size_t num );
memset是用来设置内存的，将内存中的值以字节为单位设置成想要的内容。

在 main 函数内部，定义了一个字符数组 arr，并初始化为字符串 “hello bit“。注意，数组的大小是10，所以实际上字符串后面还有一个空字符 ”。

使用 memset 函数将 arr 的前5个字节设置为字符 ‘x‘。这里的 ‘x‘ 实际上会被解释为ASCII码值，所以 ‘x‘ 会被设置为每个字节的值。因为 memset 是以字节为单位工作的，所以这里会将 arr 的前5个字节都设置为 ‘x‘ 的ASCII值。打印 arr 的内容。因为 arr 的前5个字节都被设置为了 ‘x’，所以输出将会是 “xxxxx bit“。

int main()
{
	char arr[10] = "hello bit";
	memset(arr, 'x', 5);
	//memset 在设置的时候,是以字节为单位来设置的
	printf("%sn", arr);

	return 0;
}

memcmp的函数的使用

int memcmp ( const void * ptr1, const void * ptr2, size_t num );
• 比较从ptr1和ptr2指针指向的位置开始，向后的num个字节

当ptr1<ptr2时，返回值<0

当ptr1=ptr2时，返回值=0

当ptr1>p tr2时，返回值>0

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[] = { 1,2,3,4,8 };
	int ret = memcmp(arr1, arr2, 17);
	printf("%dn", ret);

	return 0;
}

定义了两个整数数组 arr1 和 arr2。其中，arr1 包含10个整数（从1到10），而 arr2 包含5个整数（从1到4，然后有一个8）。

使用 memcm p 函数来比较这两个数组的前17个字节。需要注意的是，一个整数通常占用4个字节（这取决于系统和编译器），所以这里实际上比较的是两个数组的前4个整数以及第5个整数的部分字节。 memcmp 函数会返回两个内存区域之间的差异。如果第一个不匹配的字

在 arr1 中的值小于 arr2 中的值，则返回一个负数。如果相等，则返回0。如果 arr1 中的值大于 arr2 中的值，则返回一个正数。