内存函数（memcpy和memmove函数超详解）

原创已于 2024-04-05 16:36:10 修改 · 1k 阅读

19 ·

CC 4.0 BY-SA版权

文章标签：

#c语言

于 2023-12-04 18:09:55 首次发布

C语言专栏收录该内容

10 篇文章

订阅专栏

本文详细介绍了C语言中的内存函数，如strcpy和memcpy的基本用法，以及遇到小端存储和重叠内存时如何使用memmove和memset进行正确拷贝。强调了C语言对内存操作的限制和不同函数的适用场景。

上一章我们讲到了字符串函数及其具体实现，这一章我们来讲解内存函数的应用。像字符串函数一样，有些重要的内存函数我们也需要学会，掌握并应用。

我们先看一段代码：

int main()
{
    int arr1[] = { 1,2,3,4,5 };
    int arr2[5] = { 0 };
    strcpy(arr2, arr1);//将arr1内容拷贝到arr2里面
    //strcpy接收类型为char*,可是这是整形数组,又因为是小端存储
    //char*只能访问一个字节,只将1拷贝到arr2里面去
    return 0;
}

这里有人会问：什么是小端存储？这里可以去看我的另外一篇文章：https://mp.csdn.net/mp_blog/creation/editor/134787235

相信通过我这篇文章各位都已经理解了什么是大小端，有基础的同学会很舒服，所以预先善其事，必先利其器。

继续分析以上代码，因为strcpy函数遇到'/0'就停止，有因为是小端存储，从低地址开始访问，arr1中首个元素是1，内存中就是01 00 00 00，所以只会把第1个元素拷贝进去。

此时该如何应对？那么就该这篇文章的主角登场了：memcpy！

函数返回的地址是目的地首元素地址，第一个参数类型是目的地数组地址，第2个参数类型是源头(拷贝的内容)数组首元素地址，第3个参数是源头数组的大小(单位是字节)。

我们使用memcpy内存函数，把arr1的内存拷贝到arr2的内存中。

中。
int main()
{
    int arr1[] = { 1,2,3,4,5 };
    int arr2[5] = { 0 };
    //memcpy内存拷贝函数
    //void * memcpy(void * destination, const void * source, size_t num)
    memcpy(arr2, arr1, 5*sizeof(arr1[0]));//或者sizeof(arr1)
    int i = 0;
    for (i = 0; i < 5; i++)
    {
        printf("%d ", arr2[i]);
    }
    return 0;
}

我们在举个例子，复制结构体的内存：

struct S
{
    char name[20];
    int age;
};
int main()
{
    struct S arr3[] = { {"张三",20},{"李四"},30 };
    struct S arr4[3] = { 0 };
    memcpy(arr4, arr3, sizeof(arr3));

    return 0;
}

我们依旧来模拟实现memcpy函数：

void my_memcpy(void* dest, const void* str, size_t sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		*(char*)dest = *(char*)str;
		(char*)dest = (char*)dest + 1;
		(char*)str = (char*)str + 1;
	}
}

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

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

但是，问题来了，我们先给出代码，并看运行结果：

void my_memcpy(void* dest,const void* str, size_t sz) 
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		*(char*)dest = *(char*)str;
		(char*)dest = (char*)dest + 1;
		(char*)str = (char*)str + 1;
	}
}

int main()
{
	int arr1[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	my_memcpy(arr1 + 2, arr1, 5 * sizeof(int));
	//猜测结果应该是 1 2 1 2 3 4 5 8 9 10

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);//1 2 1 2 3 4 5 8 9 10
	}
	return 0;
}

以下是我们想要的结果：

但是实际输出是这个：

这里我们来看看原因：

当我们源数组和目的数组有共同内容时，就会出错，向strcat一样，但是strcat的解决办法有strnacat，加上指定的长度即可。一样的，解决这个问题有memmove函数。

memcpy这个函数使用有限制条件。C规定：memcpy函数处理不重叠内存的数据；memmove函数处理重叠内存的数据。可是当你使用memcpy函数时你会发现他处理的没有问题。可我们目前实现的这个代码，已经满足了C语言的规定。

int main()
{
	int arr1[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	memmove(arr1 + 2, arr1, 5 * sizeof(int));
	//这次结果就是 1 2 1 2 3 4 5 8 9 10

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

这个函数很神奇，这是怎么回事，我们将目的地址+ 3.我们来看图解：

此时内存是从后向前复制复制的。但是还是会有问题：

这时就要从前向后拷贝内存：根据以上情况，我们要分类讨论：

目标地址大于拷贝地址，我们从拷贝地址末尾开始向前拷贝，从后向前拷贝。
目标地址小于拷贝内存地址，我们从拷贝地址头部向后拷贝，从前向后拷贝。

所以有了以上基础，我们就来模拟实现memmove函数：

void my_memmove(void* dest, const void* str, size_t sz)
{
	if ((char*)dest > (char*)str)
	{
		//目的地址 > 拷贝地址
		//从后向前复制
		(char*)dest += sz - 1;
		(char*)str += sz - 1;
        //从后往前拷贝,找到最后一个内存地址
        //因为是字节拷贝,找到 拷贝数量 - 1 的地址开始拷贝
		int i = 0;
		for (i = 0; i < sz; i++)
		{
			*(char*)dest = *(char*)str;
			(char*)dest -= 1;
			(char*)str -= 1;
		}
	}
	else
	{
		//目的地址 < 拷贝地址
		//从前向后复制
		int i = 0;
		for (i = 0; i < sz; i++)
		{
			*(char*)dest = *(char*)str;
			(char*)dest += 1;
			(char*)str += 1;
		}
	}
}


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

	my_memmove(arr1 + 3, arr1, 5 * sizeof(int));
	//从后向前拷贝
	my_memmove(arr2, arr2 + 3, 5 * sizeof(int));
	//从前向后拷贝
	
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	printf("\n");
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

C语言规定：memcpy 拷贝的就是不重叠的内存，memmove 拷贝的就是重叠的内存。但是VS2022 memcpy 也可以实现重叠内存拷贝。考虑到可移植性，所以我们还是拷贝重叠内存时还是使用memmove函数。

最后一个是内存设置函数，这个其实一般就是初始化内存为0时我们使用（一般是使用指针动态开辟空间使用），针对的是每个字节。

int main()
{
    //memset设置缓冲区为一个特定的字符
    // void* memset(void* dest,  int c,  size_t count)
    //                 目的地   自己设的 改变的字节数
    // memset内存设置函数
    char arr[10] = "";
    memset(arr, '#', 10);
    return 0;
}

只能针对每个字节，否则会出现问题：

int main()
{
    int arr[10] = { 0 };
    memset(arr, 1, 10);
    //最后一个数单位是字节,把每个字节都改成1
    return 0;
}