C语言常用的内存函数

在上一篇博客中我为大家分享了一些常用的字符串函数，以及它们的用法和模拟实现。通过字符串函数中的strcpy，我们能够做到将一个字符串中的内容拷贝到另一个字符串上，可如果有一天我们想把一个整型数组中的内容拷贝到另一个整型数组中呢？这样看来好像strcpy就不适用了，因为它只能对字符串进行拷贝。那么今天所提到的内存函数就能够实现整型数组，甚至其他类型的拷贝，让我们开始今天的学习吧~！

一、memcpy函数

我们可以看到，memcpy函数的返回类型以及参数类型大多都是void类型，这也就使得它能够接收不同类型的数据，并且能够对不同类型的数据加以处理~

①memcpy函数的使用

memcpy函数的作用是：将num字节的值从源指向的位置直接复制到目标指向的内存块。由于参数为void*类型，所以源指针和目标指针指向的对象的底层类型与此函数无关。(注:这个函数在遇到 '\0' 的时候并不会停下来。)

memcpy函数的第一个参数void* destination指向目标起始位置，代表想要改变的初始位置，第二个参数const void* source指向想要复制的数据的起始位置，它的作用是作为模板为目标复制字节，第三个参数size_t表示要复制的字节数。那么了解了memcpy函数的组成，让我们举个例子，尝试一下使用memcpy函数拷贝整型数组吧~

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

甚至我们还能做到使用memcpy拷贝结构体

struct stu
{
	char name[20];
	int age;
	long id;
};
int main()
{
	struct stu s0 = { "xiaowang",20,10666 };
	struct stu s1 = { "xiaosong",40,10333 };
	memcpy(&s0, &s1, 8 * sizeof(char));
	memcpy(&s0, &s1, 7 * sizeof(int));
		printf("%s\n", s0.name);
		printf("%d\n", s0.age);
		printf("%ld\n", s0.id);
	return 0;
}

（我这里只是举一个例子，对于结构体的拷贝还需要学会结构体内存对齐，如果有机会的话下次我会单独用一篇博客来分享一下关于结构体内存对齐的知识）

②memcpy函数的模拟实现

不知道小伙伴们还记不记得我们之前学习过的qsort函数，让我们顺便回顾一下吧，qsort函数可以排序任意类型的数据，函数底层使用的是快速排序的方法。那么qsort函数是怎么做到能够排序任意类型数据的呢？没错，就是在不知道数据类型的情况下直接交换每一个字节。

而我们的memcpy函数也差不多是这个意思，我们最后传递的size_t类型参数就代表了需要替换的字节数，所以我们可以传递一个size_t类的num代表字节数，使用一个while循环，每循环一次，传递的num就减一，直到num为0时循环结束，此时正好交换了num个字节。

void* my_memcpy(void* arr0, const void* arr1, size_t num)
{
	assert(arr0 && arr1);
	while (num--)
	{
		*(char*)arr0 = *(char*)arr1;
		arr0 = (char*)arr0 + 1;
		arr1 = (char*)arr1 + 1;
	}
	return (void*)arr1;
}
int main()
{
	int arr0[20] = { 5,5,5,5,5 };
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("替换前:\n");
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", arr0[i]);
	}
	my_memcpy(arr0, arr1, 5 * sizeof(int));
	printf("\n替换后:\n");
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", arr0[i]);
	}
	return 0;
}

那我们能不能尝试自己拷贝自己，做到将arr1里的4，5，6，7，8拷贝成它的前五位元素1，2，3，4，5呢？让我们尝试一下：

void* my_memcpy(void* arr0, const void* arr1, size_t num)
{
	assert(arr0 && arr1);
	while (num--)
	{
		*(char*)arr0 = *(char*)arr1;
		arr0 = (char*)arr0 + 1;
		arr1 = (char*)arr1 + 1;
	}
	return (void*)arr1;
}
int main()
{
	int arr0[20] = { 5,5,5,5,5 };
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("替换前arr1:\n");
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	my_memcpy(arr1+3, arr1, 5 * sizeof(int));
	printf("\n替换后arr1:\n");
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

可以看到在我们想用arr1前方的元素拷贝给后方时，却打印出了错误的答案，这是为什么呢？因为在对arr1进行拷贝的时候改变的是arr1本身，当第一次拷贝时arr1中的4变成了1，第二次拷贝时5变成了2，第三次拷贝时6变成了3，第四次拷贝时，我们需要将7变成4，可是此时arr1中的4已经被替换成了1，所以此时7变成了1，同理8也变成了2。这就说明了：（memcpy函数j仅仅是简单的从前往后进行拷贝，并没有考虑内存有重叠的情况，如果内存有重叠，其行为是不确定的。）

那么此时，下一个要介绍的函数就该登场了~

二、memmove函数

可以看到memmove的参数与memcpy函数是一致的，但与memcpy函数相较，memmove函数能够完美的处理重叠的情况。

①memmove函数的使用

• 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。

• 如果源空间和目标空间出现重叠，就可以使用memmove函数处理。

那么我们使用memmove来证实上面的想法，就用刚刚memcpy打印出错的代码：

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

看来这次使用memmove确实解决了重叠的情况。

②memmove函数的模拟实现

想要实现memmove函数的模拟实现，就需要我们解决上面memcpy函数的重叠问题。那么memcpy函数的重叠问题是如何造成的呢？刚刚的思路我们可以用这张图来表示，而我们按照memcpy的思路来进行拷贝就是从前往后拷贝，用图片来表示出来应该是这样的：这就是出现了重叠的情况，我们想调用arr[3]时，其指向的元素已经从4变成了1，想要避免这种情况我们只需要在拷贝元素时保证需要拷贝的内容不被替换就好了。就比如此时，我们转换一下思路，我们现在想将1，2，3，4，5拷贝成4，5，6，7，8。这样的话能不能做到呢？是可以的！因为我们在将1拷贝成4后，拷贝的位置和需要拷贝的内容的位置都向后挪一位，此中重叠的元素为4和5，但4和5在最开始就为1和2拷贝成功啦，所以并不会发生错误的打印。这种情况就是拷贝内容初始位置在拷贝初始位置之后，此时需要使用顺序拷贝。

而对于上面将4，5，6，7，8变成1，2，3，4，5，我们可以尝试用逆序拷贝。通过这个图可以知道，拷贝内容初始位置在拷贝初始位置之前，此时需要使用逆序拷贝。通过逆序拷贝的方式，就能够避免在拷贝前，拷贝内容被替换掉的情况。

想要模拟实现memmove函数，我们只需要将两种情况结合在一起，先判断两个初始位置谁在前谁在后，然后再对应的编写出解决方案就可以啦~（拷贝内容初始位置在拷贝初始位置之后时，直接使用memcpy的模拟函数就可以，拷贝内容初始位置在拷贝初始位置之前时，就逆序拷贝，从需要拷贝的最后一个字节往前拷贝就能够解决了）

void* my_memmove(void* arr0, const void* arr1, size_t num)
{
	assert(arr0 && arr1);
	if (arr0 < arr1)
	{
		while (num--)
		{
			*(char*)arr0 = *(char*)arr1;
			arr0 = (char*)arr0 + 1;
			arr1 = (char*)arr1 + 1;
		}
	}
	else
	{
		while (num--)
			*((char*)arr0 + num) = *((char*)arr1 + num);
	}
	return (void*)arr1;
}
int main()
{
	int arr0[20] = { 5,5,5,5,5 };
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("替换前arr1:\n");
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	my_memmove(arr1 + 3, arr1, 5 * sizeof(int));
	printf("\n替换后arr1:\n");
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

这样就成功的模拟实现了memmove函数啦~

三、memset函数

memset的作用是：复制字符 value (注意,不是字符串,是一个字符)到参数 ptr 所指向的字符串的前 num 个字符。

memset和前两个函数最大的区别就是，前两个函数可以传输的是可以每一个的不同的，可以改变的，多样的。而memset能做到的只是将一个固定的字符拷贝到一段空间中。那么它的具体用法是什么呢？我们来尝试一下使用memset将一段数组进行清零。

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("清零前arr1:\n");
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	memset(arr1, 0, 10 * sizeof(int));
	printf("\n清零后arr1:\n");
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

能够看到这边也是成功清零了，那可能有人会问，那不是也可以把值全部变成1，全部变成2之类的吗？那让我们来尝试一下这个思路：欸？怎么出现了这么一堆又奇怪又大的数字，这是怎么一回事呢？请仔细看刚刚的介绍，我们传输的并不是直接的一个值，而是一个将参数转化为二进制后填入的一个字节，比如此时我们想填入的是1，那么1转换为二进制形式就是0000 0001，但是arr中存放的int整形变量有四个字节，所以传进四个字节后其实这个对应的值会变成0000 0001 0000 0001 0000 0001 0000 0001。也就是一个非常大的数字。由于之前传递的0对应的就是00 00 00 00所以会直接是0，并不是说明传递的是什么数字，就会是什么数字，想要理解memset函数，就要清楚这一点。而传递其他的值大部分比较麻烦，所以memset函数的主要作用还是使结构体或数组进行清零(注意并不是说就没有其他的作用了哦)。

四、memcmp函数

memcmp的作用是：比较从ptr1和ptr2指针指向的位置开始，向后的num个字节。

memcmp的用法与strncmp的用法很像，都是用于指定长度的比较大小，并且都是大于返回>0的数，小于返回<0的数，等于返回0。唯一不同的是memcmp函数是内存函数，通过它能够比较所有的类型，因为不论存储的内容是字符串，整数还是其它类型的数据，该函数都会逐个字节进行比较。

int main()
{
	int arr0[] = { 1,2,3,4,5,6 };
	int arr1[] = { 1,2,3,4,5,7 };
	if (memcmp(arr0, arr1, 6 * sizeof(int)) > 0)
	{
		printf("arr0>arr1");
	}
	else if (memcmp(arr0, arr1, 6 * sizeof(int)) < 0)
	{
		printf("arr0<arr1");
	}
	else
	{
		printf("arr0=arr1");
	}
	return 0;
}

由此就可以进行两个数组的大小的比较。同样字符串也是可以的：

int main()
{
	char arr0[] = "abcdef";
	char arr1[] = "abcdez";
	if (memcmp(arr0, arr1, 6 * sizeof(char)) > 0)
	{
		printf("arr0>arr1");
	}
	else if (memcmp(arr0, arr1, 6 * sizeof(char)) < 0)
	{
		printf("arr0<arr1");
	}
	else
	{
		printf("arr0=arr1");
	}
	return 0;
}

那么关于比较常用的内存函数的知识，就给大家分享到这里啦，如果有讲解的有问题或者不清楚的地方，还希望各位在评论区多多指出，我也会吸取教训，多多学习的，那么我们下期再见啦~