C语言中的内存函数

C语言中的内存函数

1. memcpy( ) 函数的应用及其模拟实现

• 函数声明：

void* memcpy(void* destination, const void* source, size_t num);

• 注意事项：

函数memcpy( )从source指向的位置开始向后复制num个字节的数据到destination指向的内存位置

该函数的使用需要包含头文件 <string.h> 并且函数在遇到字符 ‘\0’ 的时候不会停下来

如果source和destination有任何的重叠，复制的结果都是未定义的，即两块空间必须完全独立

• 使用案例：

#include<stdio.h>
#include<string.h>
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0 };
	memcpy(arr2, arr1, sizeof(arr2));//注意这里是字节个数，而不是元素个数
	for (int i = 0; i < sizeof(arr2) / sizeof(arr2[0]); i++) {
		printf("%d ", *(arr2 + i));
	}
	return 0;
}

• 模拟实现：

void* my_memcpy(void* dest, void* sour, size_t num)
{
	//该函数是以字节为单位的，我们可以使用char类型来实现拷贝
	void* ret = dest;
	for (int i = 1; i <= num; i++) {
		*(char*)dest = *(char*)sour;
		dest = (char*)dest + 1;
		sour = (char*)sour + 1;
	}
	return ret;
}
int main()
{
	double arr1[5] = { 1.1,2.2,3.3,4.4,5.5 };
	double arr2[5] = { 0 };
	my_memcpy(arr2, arr1, sizeof(arr2));//将arr1的内容拷贝到arr2中
	for (int i = 0; i < sizeof(arr2) / sizeof(arr2[0]); i++) {
		printf("%.1lf ", *(arr2 + i));
	}
	return 0;
}

输出结果：1.1 2.2 3.3 4.4 5.5

2. memmove( ) 函数及其模拟实现

• 函数声明：

void* memmove(void* destination, const void* source, size_t num);

• 注意事项：

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

• 使用案例：

#include<stdio.h>
#include<string.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    //该函数表示从该数组第一个元素开始拷贝，从第三个元素开始覆盖
	memmove(arr + 2, arr, 20);//20B代表5个int类型的元素
	int len = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < len; i++) {
		printf("%d ", arr[i]);
	}
	return 0;
}

输出结果：1 2 1 2 3 4 5 8 9 10

• 模拟实现：

#include<stdio.h>
void* my_memmove(void* dest, void* sour, size_t num)
{
	void* ret = dest;
	//从前向后
	if (dest < sour) {
		while (num) {
			*(char*)dest = *(char*)sour;
			dest = (char*)dest + 1;
			sour = (char*)sour + 1;
			num--;
		}
	}
	//从后向前
	//dest与sour本质上没有移动，依靠num的变化即可向前
	else {
		while (num) {
			*((char*)dest + num - 1) = *((char*)sour + num - 1);
			num--;
		}
	}
	return ret;
}
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 1,2,3,4,5,6,7,8,9,10 };
	//从后向前移动
	my_memmove(arr1 + 2, arr1 + 1, 8);
	//从前向后移动
	my_memmove(arr2 + 1, arr2 + 2, 8);
	int len = sizeof(arr1) / sizeof(arr1[0]);
	printf("从后向前：");
	for (int i = 0; i < len; i++) {
		printf("%d ", arr1[i]);
	}
	printf("\n");
	printf("从前向后：");
	for (int i = 0; i < len; i++) {
		printf("%d ", arr2[i]);
	}
	return 0;
}

输出结果：

从后向前：1 2 2 3 5 6 7 8 9 10
从前向后：1 3 4 4 5 6 7 8 9 10

3. memset( )函数的使用

• 函数声明：

void* memset(void* ptr, int value, size_t num);
//prt是被设置的指针，value是设置内容的值或ASCII码，num是设置的字节大小

• 注意事项：

memset( ) 函数是用来设置内存的，将内存中的值以字节为单位设置成所需的内容

• 使用案例：

#include<stdio.h>
#include<string.h>
int main()
{
	char str[] = "Hello World";
	memset(str, 'x', 5);
	printf("%s", str);
	return 0;
}

输出结果：xxxxx World

注意：由于该函数是以字节为单位设置的，再设置一些较大的类型时（例如int类型）可能会产生一些问题，例如：

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

输出结果：16843009 16843009 3 4 5

这是因为int类型的数据是4个字节，再内存中数字1是以0x00 00 00 01这样的方式存储的，将每个字节的内容均修改为一，我们就可以得到0x01 01 01 01，将其转化为十进制打印就是16843009。

4. memcmp( ) 函数的使用

• 函数声明

int memcmp(const void* ptr1, const void* ptr2, size_t num);

• 注意事项：

比较从ptr1和ptr2指针指向的位置开始，向后最多比较num个字节，返回值类似于strcmp( )函数

• 使用案例：

#include <stdio.h>
#include <string.h>
int main()
{
	char buffer1[] = "ABCDE";
	char buffer2[] = "ABCDF";
	int n = memcmp(buffer1, buffer2, sizeof(buffer1));
	if (n > 0)
		printf("'%s' is greater than '%s'.\n", buffer1, buffer2);
	else if (n < 0)
		printf("'%s' is less than '%s'.\n", buffer1, buffer2);
	else
		printf("'%s' is the same as '%s'.\n", buffer1, buffer2);
	return 0;
}

输出结果：‘ABCDE’ is less than ‘ABCDF’.