【C语言进阶】内存函数

我是果子哥

已于 2024-06-06 19:51:25 修改

阅读量874

点赞数 19

分类专栏： C语言进阶文章标签： c语言学习

于 2023-03-19 13:10:16 首次发布

本文链接：https://blog.csdn.net/adcxhw/article/details/129646678

版权

C语言进阶专栏收录该内容

10 篇文章 1 订阅

订阅专栏

天生我材必有用，千金散尽还复来。 ——李白

三.memcpy函数和memmove函数的关系

前言

上次我们学习了字符串函数：strcpy，strcat，strcmp等等字符串函数，顾名思义这些字符串函数只能对字符串进行一系列的操作，而不能对整型，浮点型之类的内容进行操作。

今天我们就要学习内存函数：memcpy，memmove，memcmp等等内存函数。前缀mem就是英文里面的memory单词的意思，而memory在计算机里面理解为内存，所以这些函数是对内存进行操作，不会被类型所限制，可以操作各种各样的类型。

一.memcpy函数

void *memcpy( void *dest, const void *src, size_t count )，这里为什么要用void*的指针呢？

因为这是一个内存函数，我们可以操作各种的数据类型，void*的指针可以接收任何类型的指针。在要使用的时候，只需要将void*强制类型转换即可达到目的。

1.实现memcpy函数

#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, 20);//20也就是20个字节，即拷贝5个整型
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

2.模拟实现memcpy函数

void* my_memcpy(void* dest, const void* src, size_t num)
{
	assert(dest && src);
	void* start = dest;
	while (num)//一共20个字节
	{
		*(char*)dest = *(char*)src;//一个一个字节的进行拷贝
		dest = (char*)dest + 1;
		src = (char*)src + 1;
		num--;//直到num为0个字节时，即拷贝结束
	}
	return start;
}
int main()
{
   int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
   int arr2[10] = { 0 };
   my_memcpy(arr2, arr1, 20);//20也就是20个字节，即拷贝5个整型
   int i = 0;
   for (i = 0; i < 5; i++)
   {
	printf("%d ", arr2[i]);
   }
   return 0;
}

当我们要把自己数组的内容给拷贝的自己的数组内容上会发生什么？

void* my_memcpy(void* dest, const void* src, size_t num)
{
	assert(dest && src);
	void* start = dest;
	while (num)//一共20个字节
	{
		*(char*)dest = *(char*)src;//一个一个字节的进行拷贝
		dest = (char*)dest + 1;
		src = (char*)src + 1;
		num--;//直到num为0个字节时，即拷贝结束
	}
	return start;
}
int main()
{
   int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
   my_memcpy(arr+2, arr, 20);//在一个数组里面操作
   int i = 0;
   for (i = 0; i < 10; i++)
   {
	printf("%d ", arr[i]);
   }
   return 0;
}

我们的目的是arr数组里面的3 4 5 6 7改为1 2 3 4 5，结果应该是1 2 1 2 3 4 5 8 9 10。结果是什么呢？让我们一起来看看。

结果为什么是这样呢？我们不妨通过画图来理解一下，在做题时，画图时非常重要的。

这里就是有重叠的部分，在对于有重叠的部分，我们使用memmove函数。

二.memmove函数

1.实现memmove函数

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

2.模拟实现memmove函数

void* my_memmove(void* dest, void* src, size_t num)
{
	assert(dest && src);
	void* start = dest;
	while (num)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
		num--;
	}
	return start;
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr+2, arr, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

为什么又是这样，到这里可能人都要被气成sb，但是我们要心平气和，继续我们的画图来好好的来理解一下。

正确的代码：

void* my_memmove(void* dest, void* src, size_t num)
{
	assert(dest && src);
	void* start = dest;
	if(dest>src)
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	else
	{
		while (num)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
			num--;
		}
	}
	return start;
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr+2, arr, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

三.memcpy函数和memmove函数的关系

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	memcpy(arr + 2, arr, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

这里可以看出数组即使有重叠的部分，但是memcpy函数一样的可以实现和memmove函数一样的功能。我们可以这样理解：其实memcpy函数是memmove函数的一个子函数。

在vs平台上memcpy函数和memmove的功能一模一样，但是并不保证在其他平台上面两个函数的功能是一样的。

总结：在有重叠部分的时候都用memmove函数。没重叠部分的，两个函数用谁都行。

四.memcmp函数

1.实现memcmp函数

memcmp函数也是一个字节一个字节的进行比较。同样和strcmp函数一样，最后比较的是ASCll码值。

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 1,2,3,4,5,7 };
	int ret=memcmp(arr1, arr2, 20);
	printf("%d\n", ret);
	return 0;
}

比较21字节会是怎么样呢？

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 1,2,3,4,5,7 };
	int ret=memcmp(arr1, arr2, 21);//比较21字节会是怎么样呢？
	//前20个字节都相等，这是毋庸置疑的的
	//6的小端字节序：06 00 00 00
	//7的小端字节序：07 00 00 00
	//很明显7的第一个字节大于6，即arr2大于arr1，返回-1
	printf("%d\n", ret);
	return 0;
}

2.模拟实现memcmp函数

模拟实现memcmp函数和模拟实现strcmp函数是非常相似的。

int my_memcmp(const void* buf1, const void* buf2, size_t num)
{
	assert(buf1 && buf2);
	size_t m = num;
	while (num--)
	{
		if (*(char*)buf1 == *((char*)buf2))
		{
			buf1 = (char*)buf1 + 1;
			buf2 = (char*)buf2 + 1;
		}
		else
			return (*(char*)buf1 - *((char*)buf2));
	}
	return 0;//退出循环都没有return，那么就说明两个是相等的。
}
int main()
{
	int arr1[10] = { 1,2,4,4,5,6,7,8,9,10 };
	int arr2[10] = { 1,2,5 };
	int ret = my_memcmp(arr1, arr2, 9);//比较9个字节
	if (ret == -1)
	{
		printf("arr1小于arr2\n");
	}
	else if (ret == 1)
	{
		printf("arr1大于arr2\n");
	}
	else
		printf("arr1和arr2相等\n");
	return 0;
}

五.memset函数

void *memset(void *str, int c, size_t n)
//str -- 指向要填充的内存块。
//c -- 要被设置的值。该值以 int 形式传递，但是函数在填充内存块时是使用该值的无符号字符形式。
//n -- 要被设置为该值的字符数。

代码实现：

int main()
{
	char arr[20] = "hello world";
	memset(arr, '*', 5);//将arr的前五个字节改为*
	printf("%s\n", arr);
}

如果我们要对整数进行操作呢？

int main()
{
	int arr[10] = { 1,2,3,4,5 };
	memset(arr, 1, 8);//操作8个字节
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}