第十五讲：C语言内存函数

这一讲所讲的全部都是C语言中的内存函数，与字符函数和字符串函数不同的是，该函数可以处理所有类型的数据（整形数据、浮点型数据）

总结：
1.可以改变目标空间的地址，决定拷贝位置（arr1+2）
2.可以改变源空间地址，决定从哪拷贝（arr2+2）
3.可以通过sizeof（arr[0]）*2来决定复制几个字符

1.memcpy函数的使用和模拟实现

1.1函数原型

该函数负责将源内存块的count个字节复制到目标内存块上，包含在头文件<string.h>中

void *memcpy( void *dest, const void *src, size_t count );

参数：
1.dest：表示目标内存块地址
2.src：表示源内存块地址
3.count：表示要复制的字节数
返回值：
改函数返回的是目标内存块的起始指针

1.2函数的使用

//1.2函数的使用
int main()
{
	char arr1[20] = "xxxxxxxxx";
	char arr2[] = "abcdef";

	char* a1 = memcpy(arr1, arr2, 3);//abcxxxxxx
	//将arr2数组中的三个字节复制到arr数组中
	printf("a1 = %s\n", a1);

	char* a2 = memcpy(arr1, arr2+2, 3);//cdexxxxxx
	//当然，我们可以通过改变指针，来确定在哪进行复制
	printf("a2 = %s\n", a2);

	char* a3 = memcpy(arr1+2, arr2, 3);
	//我们还可以改变目标字符串的地址，但是memcpy函数返回的是目标字符串的地址
	printf("a3 = %s\n", a3);//abcxxxx
	printf("arr = %s\n", arr1);//xxabcxxxx
	return 0;
}

1.3函数使用的注意事项

• 该函数在遇到\0的时候并不会停止
• 如果源字符串和目标字符串重叠，或者说他们指向一个数组时，复制的结果是未定义的，也就是说，memcpy函数只负责不同数组之间内存块的拷贝，同个数组中我们可以使用memmove函数

下面我们来讨论如果将源字符串和目标字符串重叠时，会发生什么：

//1.3函数使用的注意事项
int main()
{
	char arr1[20] = "abcdef";

	char* a1 = memcpy(arr1+1, arr1, 3);
	printf("a1 = %s\n", a1);//结果可能为aaaaef
	return 0;
}

这是因为每次复制都会改变目标字符串中的字符，影响后面的复制

1.4memcpy函数的模拟实现

//1.4memcpy函数的模拟实现
#include <assert.h>

void* Mymemcpy(void* dest, const void* src, size_t count)
{
	char* start = dest;
	assert(dest && src);

	for (int i = 0; i < count; i++)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}

	return start;
}

//当然，除了使用for循环，我们还可以使用while循环
void* Mymemcpy1(void* dest, const void* src, size_t count)
{
	char* start = dest;
	assert(dest && src);

	while(count--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}

	return start;
}

int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "fdggdfg";

	char* a1 = memcpy(arr1, arr2+2, 3);
	printf("a1 = %s\n", a1);

	char* a2 = Mymemcpy(arr1, arr2+2, 3);
	printf("a2 = %s\n", a2);

	char* a3 = Mymemcpy1(arr1, arr2 + 2, 3);
	printf("a3 = %s\n", a3);
	return 0;
}

2.memmove函数的使用和模拟实现

2.1函数原型

void *memmove( void *dest, const void *src, size_t count );

该函数是将源内存块的count个字节拷贝到目标内存块中

和memcpy不同的是，该函数可以对内存块重叠的两块空间进行拷贝，可以说：可以使用memmove来代替使用memcpy函数

2.2函数使用

2.2.1使用函数处理整形数据

//2.2.1使用函数处理整形数据
int main()
{
	int arr1[20] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[] = {6,7,8,9,10};

	memmove(arr1, arr2, sizeof(arr2[0])*5);
	return 0;
}

这时就实现拷贝啦~：

2.2.2使用函数处理重叠类型（源空间和目标空间重叠）

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

	memmove(arr1+1, arr1, sizeof(arr1[0]) * 5);
	return 0;
}

这时函数就完全可以实现重叠区域的拷贝了✌

2.3memmove函数的模拟实现

我们先对函数模拟实现的方法进行简单的分析：

令一种情况，也就是src<dest时，我们就需要从后向前复制，所以该函数的模拟实现如下：

//2.3memmove函数的模拟实现
char* Mymemmove(char* dest, const char* src, size_t count)
{
	assert(dest && src);

	if (src > dest)
	{
		while (count--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		
		while(count--)
		{
			*((char*)dest + count) = *((char*)src+count);
		}
	}
}

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

	Mymemmove(arr1, arr1+1, sizeof(arr1[0]) * 5);
	return 0;
}

3.memset函数的使用

3.1函数原型

void *memset( void *dest, int c, size_t count );

该函数的作用是将内存块上的每个字节都设置为指定的值

函数参数：
1.dest：指向要填充的内存块的指针，表示要填充的内存块的首地址
2.c：第二个参数为int类型，它是要填充的值，虽然它为int类型，但是在使用时，会先将该值转换成char类型再填充内存
3.count：表示要填充的内存数
函数返回值：
函数返回的是目标空间的首地址

3.2函数使用注意事项

3.2.1对于整形变量的设置

//3.2.1对于整形变量的设置
int main()
{
	//我们假设要将arr数组中的前4个数设置成1
	int arr[10] = { 1,2,3,4,5,6 };

	memset(arr, 1, 16);
	return 0;
}

对于上面的代码，结果为：

这是因为：
对于填充的值，会先被转换成char类型，再进行填充，填充规则如下：

3.3函数的具体使用

使用函数完成初始化函数

//3.3.1使用函数完成初始化函数
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };

	memset(arr, 0, sizeof(arr));

	for (int i = 0; i < 10; i++)
		printf("%d ", arr[i]);
	return 0;
}

此外，函数还可以进行结构体清空等操作

4.memcmp函数的使用

4.1函数原型

int memcmp( const void *buf1, const void *buf2, size_t count );

该函数是将buf1内存块和buf2内存块进行比较，比较的方法是对应内存块逐字节比较

函数返回值：
该函数返回值和strcmp函数返回值相同：

4.2函数使用

注意：
函数是逐字节进行比较，当某一刻字节数不一样时，就返回对应的值

//4.2函数使用
int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 1,2,3,4,6 };

	int ret1 = memcmp(arr1, arr2, 16);
	//两个数组前16个字节相同，返回0
	printf("ret1 = %d\n", ret1);

	int ret2 = memcmp(arr1, arr2, 17);
	//从第17个字节开始不同，而且6>5，arr2>arr1，返回一个负值
	printf("ret2 = %d\n", ret2);
	return 0;
}