【C语言】内存操作函数

【C语言】内存操作函数

前言

内存操作函数，可以通过访问地址的形式来对内存进行修改。本篇文章简单介绍了 memcpy、memmove、memcmp，和 memset 的使用及其模拟实现

它们的头文件 <string.h>

本篇文章用到的网站 cplusplus.com

一、memcpy

1.说明

1.函数 memcpy 从 source 的位置开始向后复制 num 个字节到 destination 的内存，并返回目标空间的起始地址

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

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 0,0 };

    //将 arr2 中的前两个数复制到 arr1 中
    memcpy(arr1, arr2, 8);  //两个 int 整型，共 8 个字节

    for (int i = 0; i < 5; i++)
    {
        printf("%d ", arr1[i]);
    }
    return 0;
}

运行结果：

2.此函数遇到 ‘\0’ 并不会停止

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

int main()
{
	char str1[] = "xxxxxxxxxx";
	char str2[] = "ab\0cd";
	
    //将 str2 复制到 str1
	memcpy(str1, str2, 5);

	int sz = sizeof(str1) / sizeof(str1[0]);
	for (int i = 0; i < sz; i++)
	{
		printf("%c ", str1[i]);
	}
	return 0;
}

运行结果：

3.如果 source 和 destination 有任何的重叠，那么结果都是未定义的

如果 source 指向的空间和 destination 指向的空间有重叠，如下图：
我们想把 1 2 3 4 5 复制到 3 4 5 6 7 中，这种情况下，3 4 5 是重叠部分

而 memcpy 并未定义如何处理这种有重叠的情况，这时应使用 memmove
但我们不妨推测一下结果如何

我们期望结果是 1 2 1 2 3 4 5 8
而实际是这样的：1->3,，2->4， 3被覆盖为1，4被覆盖为2，后面如此循环，最终结果为 1 2 1 2 1 2 1 8

2.模拟实现

不考虑内存重叠的情况下，我们来模拟实现一下 memcpy

参数部分：void* des, const void* src, size_t num 用于接受任意类型的数据，其中源头数据不需要做出修改，用 const 修饰
返回部分：返回目标空间的起始地址，用 void* 来接收

由于 void 类型指针不可以直接进行解引用或者加减操作，我们使用前要进行强制类型转换，转换为 char 类型指针，每次操作只访问一个字节，对多少字节进行修改由参数 num 来决定

#include <stdio.h>
void* my_memcpy(void* des, const void* src, size_t num)
{
	void* ret = des;
	int i = 0;
	for (i = 0; i < num; i++)
	{
		*(char*)des = *(char*)src;
		des = (char*)des + 1;
		src = (char*)src + 1;
	}
	return ret;
}

int main()
{
	char str1[] = "xxxxxxxxxx";
	char str2[] = "ab\0cd";

	my_memcpy(str1, str2, 5);

	int sz = sizeof(str1) / sizeof(str1[0]);
	for (int i = 0; i < sz; i++)
	{
		printf("%c ", str1[i]);
	}
	return 0;
}

运行结果：

二、memmove

1.说明

memmove 和 memcpy 的功能和用法基本相同，差别就是 memmove 处理的源内存块和目标内存块可以重叠

将 1 2 3 4 5 拷贝到 3 4 5 6 7，期望结果是 1 2 1 2 3 4 5 8

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

符合期望结果

2.模拟实现

这里分两种情况：

1.源内存地址在前，目标内存地址在后 src < des

将 1 2 3 4 5 拷贝到 3 4 5 6 7，红色为重叠部分，期望结果 1 2 1 2 3 4 5 8

如果直接从前向后进行拷贝的话，我们会发现，重叠部分在使用之前就会被覆盖掉
那我们就从后向前拷贝：5->7，4->6，3->5，2->4，1->3，重叠部分在使用之后才会被覆盖掉

2.源内存地址在后，目标内存在前 src > des

将 3 4 5 6 7 拷贝到 1 2 3 4 5，期望结果 3 4 5 6 7 6 7 8

这种情况下，从后向前拷贝反而会将重叠部分原本的数据覆盖
可以从前向后拷贝，3->1，4->2，5->3，6->4，7->5，数据没有被覆盖

代码

参数和返回部分与 memcpy 一致

#include <stdio.h>
void* my_memmove(void* des, void* src, size_t num)
{
	void* ret = des;
	//从后向前
	if (src < des)
	{
		while (num--)
		{
			*((char*)des + num) = *((char*)src + num);
		}
	}
	//从前向后
	else
	{
		while (num--)
		{
			*(char*)des = *(char*)src;
			des = (char*)des + 1;
			src = (char*)src + 1;
		}
	}
}

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

	my_memmove(arr1 + 2, arr1, 20);
	my_memmove(arr2, arr2 + 2, 20);

	for (int i = 0; i < 8; i++)
	{
		printf("%d ", arr1[i]);
	}

	printf("\n");

	for (int i = 0; i < 8; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

运行结果

符合预期

三、memcmp

1.说明

比较机制

以字节为单位，将 ptr1 和 ptr2 开始向后 num 个字节的内存进行比较，两块内存中的值相等就继续，直到两块空间内的值不同或者比较完 num 个字节后就返回
遇到 ‘\0’ 不会停止

返回值

返回值 < 0，两块内存中第一次出现不相等的值，ptr1 指向的值 < ptr2 指向的值
返回值 = 0 ，两块内存中存放的值完全相同
返回值 > 0，两块内存中第一次出现不相等的值，ptr1 指向的值 > ptr2 指向的值

#include <stdio.h>
#include <string.h>
int main()
{
	char str1[] = "abcdefg";
	char str2[] = "abc";
	int ret = memcmp(str1, str2, 4);
	printf("%d", ret);
	return 0;
}

运行结果

2.模拟实现

因为只需要作比较，不需要修改，所以用 const 修饰参数

当内存中的值相等，就继续下个字节的比较
不相等，两块内存中的值相减，返回相减得到的值
当 num 个字节比较完后还没返回，说明两块内存中没有不相等的值，返回 0

#include <stdio.h>
int my_memcmp(const void* ptr1, const void* ptr2, size_t num)
{
	while (num--)
	{
		if (*(char*)ptr1 != *(char*)ptr2)
		{
			return *(char*)ptr1 - *(char*)ptr2;
		}
		ptr1 = (char*)ptr1 + 1;
		ptr2 = (char*)ptr2 + 1;
	}
	return 0;
}
int main()
{
	char str1[] = "abcdefg";
	char str2[] = "abc";
	int ret = my_memcmp(str1, str2, 4);
	printf("%d", ret);
	return 0;
}

四、memset

1.说明

以字节为单位，将 ptr 指向的内存块中的前 num 个字节的值设置为value，返回这块内存的起始地址

假设一个数组 arr 中存放有数字 1~10 ，那我们能不能通过调用 memset 将arr中的数字全部设置为 1 呢？

	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	memset(arr, 1, 40);

来看看结果：

为什么和我们期望的结果不同呢？因为 memset 是逐字节进行设置值的

看下内存就知道了

可以看到，数据的每个字节都被设置为了 1 ， int 的大小是 4 个字节，每个字节都是 1 的话，整体就不是 1 了，自然就和期望的结果不同了
如果都设置为 0 的话，可以达到初始化的效果

2.模拟实现

将数组 arr 初始化为0

void* my_memset(void* ptr, int value, size_t num)
{
	void* ret = ptr;
	while (num--)
	{
		*(char*)ptr = value;
		ptr = (char*)ptr + 1;
	}
	return ret;
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memset(arr, 0, 40);
	return 0;
}

效果：

结束，再见 😄