内存函数及模拟实现

---

前言

由于上篇文章中我们提到的 strcpy(),strcat(),strcmp()都只对字符串有效，那么库函数中是否存在另外一些函数更具通用性呢，一些既能对字符串，也能对浮点型，整型类型起作用的函数呢？答案是有的！它们就是内存函数，分别为memcpy(),memmove(),memset(),memcmp()

不允许内存重叠的内存拷贝函数：memcpy

将num字节的值从源指向的位置直接复制到目标指向的内存块。
该函数不检查源文件中的任何终止空字符，它总是精确地复制num个字节。
源文件和目标内存都至少应该大于等于num个字节，且两段内存不应该重叠！

使用案例

#include<stdio.h>
#include<string.h>
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[] = { 5,4,3,2,1 };
	memcpy(arr1, arr2, sizeof(arr2));
	for (int i = 0; i < sizeof(arr1)/sizeof(int); i++)
	{
		printf("%d ", arr1[i]);
	}
	printf("\n");
	
	float arr3[10] = { 2.1,2.2,2.3,2.4,2.5 };
	float arr4[] = { 1.1,1.2,1.3,1.4,1.5,1.6 };
	memcpy(arr3, arr4, sizeof(arr4));
	for (int i = 0; i < sizeof(arr3)/sizeof(float); i++)
	{
		printf("%.1f ", arr3[i]);
	}
	printf("\n");
	
	char arr5[20] = "hello world";
	char arr6[] = "good night";
	char* ret = (char*)memcpy(arr5, arr6, 6);
	printf("%s\n", ret);

	return 0;
}

模拟实现

void* my_memcpy(void* dest, 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;
	}
	return ret;
}

允许内存重叠的内存拷贝函数：memmove

memmove 的作用与memcpy的作用几乎相同，但是memmove允许存在内存重叠的情况

使用案例

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr + 3, arr, 5 * sizeof(int));

	return 0;
}

模拟实现

思路：
对于内存的拷贝，有多种不同情况：
1.dest目标数组的首地址大于src拷贝数组的首地址，如果采用从前向后拷贝，则会造成src末尾数据被覆盖的现象。需要采用从后往前拷贝，以确保每个元素都能在不被前面数据覆盖下成功拷贝。
从前往后拷贝：1和2把4和5覆盖掉（不正常），变成1 2 3 1 2 6 7 8；再把3覆盖掉（正常），变成1 2 3 1 2 3 7 8；再把覆盖在4和5上的1 2覆盖在7和8上（不正常），变成1 2 3 1 2 3 1 2

2.dest目标数组的首地址小于src拷贝数组的首地址，如果采用从后往前拷贝，则会造成src的头部数据被覆盖
src的尾部数据7和8将src的头部数据4和5进行覆盖，导致在将src头部数据4和5拷贝进dest的头部时数据不同

3.没有内存重叠出现
无论上述哪种方法都能实现

void* my_memmove(void* dest, void* src, size_t num)
{
	assert(dest && src);
	void* ret = dest;
	//情况一
	if (dest > src)
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	//情况二和三
	else
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	return ret;
}

内存设置函数：memset

作用：

将指针所指向的内存的num个字节设置为指定的值

使用案例

避坑题

现在我有一个具有20个int类型元素的数组，想要将它们全部设置为1，以下程序是否可以完成？

int main()
{
	int arr[20];
	memset(arr,1,sizeof(arr));
	return 0;
}

解析：

memset是一个内存设置函数，其每次设置的空间大小为1个字节，也就是说这个程序将把1按一个字节一个字节设置在内存中，每四个字节也就是一个int类型的元素设置后的数据为0000 0001 0000 0001 0000 0001 0000 0001，换算成16进制就是01 01 01 01，所以这个程序无法完成任务！

模拟实现

void* my_memset(void* ptr, int val, size_t num)
{
	assert(ptr);
	void* ret = ptr;
	while (num--)
	{
		*((char*)ptr) = val;
		ptr = (char*)ptr + 1;
	}
	return ret;
}

内存比较函数:memcmp

比较ptr1和ptr2所指向的num个字节,
如果ptr1大于ptr2，返回大于0的数
如果ptr1小于ptr2，返回小于0的数
如果ptr1等于ptr2，返回0
该函数与strcmp不同：遇到’\0’不会停止比较

使用案例

模拟实现

int my_memcmp(const void* ptr1, const void* ptr2, size_t num)
{
	assert(ptr1 && ptr2);
	size_t count = 1;
	while (count < num && *(char*)ptr1 == *(char*)ptr2)
	{
		count++;
		ptr1 = (char*)ptr1 + 1;
		ptr2 = (char*)ptr2 + 1;
	}
	return *(char*)ptr1 - *(char*)ptr2;
}