C语言内存函数-CSDN博客

#include<stdio.h>
#include<string.h>
int main()
{
	int des[] = { 1,2,3,4 };
	int src[] = { 5,6,7,8 };
	memcpy(des, src, 8);//从src拷贝8个字节的数据到des
	for (int i = 0; i < 4; i++)
		printf("%d ", des[i]);
	printf("\n");
	return 0;
}

需要注意的是：数组src每个元素为int，因此拷贝8个字节就相当于拷贝了两个元素。

接下来是对函数的模拟实现：

#include<stdio.h>
#include<string.h>
#include<assert.h>
void* my_memcpy(void* des, const void* src, size_t num)
{
	assert(des && src);
	char* s1 = (char*)des;
	char* s2 = (char*)src;
	while (num--)
	{
		*s1++ = *s2++;
	}
	return des;
}

int main()
{
	int des[] = { 1,2,3,4 };
	int src[] = { 5,6,7,8 };
	my_memcpy(des, src, 8);//从src拷贝8个字节的数据到des
	for (int i = 0; i < 4; i++)
		printf("%d ", des[i]);
	printf("\n");
	return 0;
}

上面用的示例是两块内存没有重叠的情况，那么如果两块内存有重叠会是什么结果呢？

代码如下：

#include<stdio.h>
#include<string.h>
#include<assert.h>
void* my_memcpy(void* des, const void* src, size_t num)
{
	assert(des && src);
	char* s1 = (char*)des;
	char* s2 = (char*)src;
	while (num--)
	{
		*s1++ = *s2++;
	}
	return des;
}
int main()
{
	int arr[] = { 1,2,3,4 };
	memmove(arr+1, arr, 8);//从src拷贝8个字节的数据到des
	for (int i = 0; i < 4; i++)
		printf("%d ", arr[i]);
	printf("\n");
	return 0;
}

可以看到，目标内存块与源内存块有一块内存重叠了，如果用memcpy来实现内存拷贝的话，

就会达不到预期效果。（预期是1 1 2 4）

要分析拷贝过程，可以将过程分为两步：

第一步：

目标内存块(存储2)被源内存块(存储1)数据覆盖，结果为1 1 3 4

指针src和des往后移动一步。

第二步：

目标内存块（3）被源内存块（1）数据覆盖，最终结果为：1 1 1 4

因此最终结果是：1 1 1 4

注意：如果des与src之间有内存重叠，对于重叠的内存，交给memmove来处理。

2. memmove使用和模拟实现

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

功能：该函数与memmove的区别就是它处理的目标内存块和源内存块是可以重叠的。

如果源空间和目标空间出现重叠，就要用memmove函数（而不是memcpy）。

使用示例：

#include<stdio.h>
#include<string.h>
int main()
{
	int arr[] = { 1,2,3,4 };
	memmove(arr+1, arr, 8);//从src拷贝8个字节的数据到des
	for (int i = 0; i < 4; i++)
		printf("%d ", arr[i]);
	printf("\n");
	return 0;
}

可以看到，使用memmove函数，即使目标空间和源空间有内存重叠也能达到预期要求。

那么memmove是怎么实现的呢？

接下来看memmove函数的模拟实现：

#include<stdio.h>
#include<string.h>
#include<assert.h>

void* my_memmove(void* des, const void* src, size_t num)
{
	char* s1 = (char*)des;
	char* s2 = (char*)src;
	while (num--)
	{
		if (src < des)
		{
			*(s1 + num) = *(s2 + num);//从后往前
		}
		else
		{
			*s1++ = *s2++;//从前往后
		}
	}
	return des;//返回des地址
}
int main()
{
	int arr[] = { 1,2,3,4 };
	my_memmove(arr+1, arr, 8);//从src拷贝8个字节的数据到des
	for (int i = 0; i < 4; i++)
		printf("%d ", arr[i]);
	printf("\n");
	return 0;
}

如图分析：

要解决内存重叠问题，关键在于两个指针的先后关系。

可以看到，src和des两个指针的关系无非就是三种：小于(左边)，大于(右边)，和等于(重合)

①当src在des左边时：

目标空间前面部分与源空间内存重叠，如果从前往后拷贝就会导致源空间后面部分被覆盖。

因此需要从后往前拷贝，这样就不会影响到源空间后面的内容。

②当src在des右边时：

目标空间后面部分与源空间内存重叠，如果从后往前拷贝就会导致源空间前面部分被覆盖。

因此需要从前往后拷贝，这样就不会影响到源空间前面的内容。

③当src与des重合时：

当目标空间与源空间重合时（或者源空间被包含在目标空间内），此时源空间所有内存都与目标空间重叠。此时无论是从后往前还是从前往后结果都不会受影响。

3. memset函数的使用

void * memset ( void * ptr, int value, size_t num );

功能：memset函数是⽤来设置内存的，将内存中的值以字节为单位设置成想要的内容。

使用示例：

#include<stdio.h>
#include<string.h>
int main()
{
	char arr[] = "Hello World";
    printf("%s\n", arr);
	memset(arr, 'x', 6);//将前六个字节数据改成'x'
	printf("%s\n", arr);
}

4. memcmp函数的使用

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

功能：比较从ptr1和ptr2指针指向的位置开始，向后的num个字节的数据，并返回值说明。

返回值如下：(来源于网站cplusplus:memcmp - C++ Reference (cplusplus.com))

翻译：

①当ptr1指向的内存数据小于ptr2指向的内存数据时返回一个负数。

②当ptr1指向的内存数据大于ptr2指向的内存数据时返回一个正数。

③当ptr1指向的内存数据等于ptr2指向的内存数据时返回0。

使用示例：

#include<stdio.h>
#include<string.h>
int main()
{
	char str1[] = "AABCD";
	char str2[] = "AABCA";
    //比较字符串前5个字节
	if (memcpy(str1, str2, 5) > 0)
		printf("str1大于str2\n");
	else if(memcpy(str1, str2, 5) < 0)
		printf("str1小于str2\n");
	else if(memcpy(str1, str2, 5) == 0)
		printf("str1等于str2\n");
	return 0;
}

运行结果：