C语言内存函数详解

内存函数

本章内容主要讲解：memcpy(内存拷贝函数)，memmove(内存移动函数)，memcmp(内存比较函数)的基本作用和模拟实现。

1.内存函数的介绍

1.memcpy函数

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

函数功能：从source指向的内存空间处拷贝num个字节的内容到destination指向的内存中，当拷贝的内容是'\0'时，函数不会主动停下来，除非拷贝的内容达到了num个字节。

使用案例：将arr2数组拷贝进arr1数组。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int arr1[10] = { 0 };
	int arr2[10] = { 1,2,3,4,5,6,7,8,9,10 }; 
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	memcpy(arr1, arr2, sizeof(arr2));
	printf("\n");
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

注意：destination和source最好不要指向同一个内存空间，否则结果会变得不可控。

当destination和source指向同一块内存空间时，结果会变得不可控：

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	memcpy(arr+1, arr, 20);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
    //arr数组经过拷贝之后：1,1,2,3,4,5,7,8,9,10
	return 0;
}

在较低版本的编译器中，memcpy的拷贝方式是将source中的内容由低地址向高地址开始依次拷贝进destination的内存空间中，通俗来讲就是从前向后拷贝，但这种拷贝方式是有弊端的。例如这里，destination是arr+1，source是arr。拷贝的空间为20个字节，也就是5个整型，预期结果应该就是如图的运行结果。但是在较低版本的编译器中却不是如此的结果。

分析：这里先将1移动到2的位置，2被覆盖。接着应该是将2这个值给移动到3这里，但是2已经被修改为1了，所以此时实际上是将1把3给覆盖掉了，这这样一直持续到结束。结果就变成了[1，1，1，1，1，1，7，8，9，10]。所以此时这种指向同一内存空间的情况时，就需要用到memmove函数了

解决方案：此时就需要从后向前拷贝了。这样就不会覆盖src中待拷贝的内容了。

那么就不难看出：

当src>des时，就使用从后向前拷贝的方式。

当src<=des时，就使用从前向后的拷贝方式。

（这也就是memmove函数的内核，memmove函数会根据src和des的大小，选择不同的拷贝方式）

注意：这里由于我使用的visual studio是2022版本，所以这个问题就被规避了，但是倘若使用的较低版本的visual studio编译器，例如：2019版本的，其运行结果并不在我们的预期之中。

2.memmove函数

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

函数功能：与memcpy函数的功能一样，不过区别是memmove函数处理的源内存块和目标内存块是可以重叠的。当destination和source指向的内存空间会发生重叠的可能性时，就得使用memmove函数进行处理。

使用案例：

int main()
{
	int arr1[10] = { 0 };
	int arr2[10] = { 1,2,3,4,5,6,7,8,9,10 };
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	memmove(arr1, arr2, sizeof(arr2));
	printf("\n");
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

3.memcmp函数

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

函数功能：比较从ptr1和ptr2指针指向的前num个字节的内容。

返回值：

• 若ptr1大于ptr2，返回一个大于0的数
• 若ptr1等于ptr2，返回0
• 若ptr1小于ptr2，返回一个小于0的数

使用案例：（比较两个字符串前6个字节的内容）

#include<stdio.h>
#include<stdlib.h>
int main()
{
	char* p1 = "abcdef";
	char* p2 = "abbcde";
	printf("%d ", memcmp(p1, p2, 6));
	return 0;
}

2.内存函数的模拟实现

1.memcpy函数的模拟实现

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
void* my_memcpy(void* des,const void* src,size_t num)
{
    void* ret = des;
	assert(des);
	assert(src);
	while (num--)
	{
		*(char*)des = *(char*)src;
		des = (char*)des + 1;
		src = (char*)src + 1;
	}
    return ret;
}

注意：这里由于memcpy函数的前两个参数都是void*类型，所以需要转化成char*进行逐字节赋值比较方便。

2.memmove函数的模拟实现

当src>des时，就使用从后向前拷贝的方式。

当src<=des时，就使用从前向后的拷贝方式。

（这也就是memmove函数的内核，memmove函数会根据src和des的大小，选择不同的拷贝方式）

void* my_memmove(void* des, const void* src, size_t num)
{
	void* ret = des;
	if (des < src)//容易将src给改变，所以就是从后向前拷贝
	{
		while (num--)
		{
			*((char*)des + num) = *((char*)src+num);
		}
	}
	else//从前向后拷贝
	{
		while (num--)
		{
			*(char*)des = *(char*)src;
			des = (char*)des + 1;
			src = (char*)src + 1;
		}
	}
	return des;
}

3.memcmp函数的模拟实现

int my_memcmp(const void* des, const void* src, size_t num)
{
	assert(des);
	assert(src);
	while (*(char*)des == *(char*)src && num--)
	{
		des = (char*)des + 1;
		src = (char*)src + 1;
	}
	if (num == 0)
		return 0;
	else
	return (*(char*)des - *(char*)src);
}

3.完结

本章的内容就到这里啦，若有不足，欢迎评论区指正，下期见！