【C语言进阶】内存函数

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

 

目录

前言

一.memcpy函数

​1.实现memcpy函数

2.模拟实现memcpy函数

二.memmove函数

1.实现memmove函数

2.模拟实现memmove函数 

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

四.memcmp函数

1.实现memcmp函数

2.模拟实现memcmp函数 

五.memset函数 

---

前言

上次我们学习了字符串函数：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
#include//内存函数的头文件
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;
}

这里为什么为得到这么奇怪的数字呢？

注意：memset是一个一个字节的进行操作，而int是4个字节为一个数字。 

如：1的小端字节序是 01 00 00 00，然后一个一个字节的改为1，最后就成了 01 01 01 01，

16进制的01010101就是16843009。

所以memset不能随便用，有可能会带来不一样的结果。要根据实际情况来使用。

感谢老铁们的支持。