C语言【进阶篇】- 部分内存函数的使用以及模拟实现

1.memcpy的使用以及模拟实现

2.memmove的使用以及模拟实现

目录

1.memcpy的使用以及模拟实现

2.memmove的使用以及模拟实现

---

1.memcpy的使用以及模拟实现

 memcpy函数的简单理解：

memcpy函数是内存拷贝，可以拷贝字符串、整型数组、结构体数据，因此用void *dest，这种指针类型变量可以接收任意类型的地址，谁的地址都能放到这。 

第一个参数是指向目的地的，第二个参数是指向源头的，第三个参数你要拷贝多少个字节。

·函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
·这个函数在遇到 '\0' 的时候并不会停下来。
·如果source和destination有任何的重叠，复制的结果都是未定义的。

1.memcpy函数的使用：

（1）整型的拷贝

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
 
int main()
{
	int arr1[] = { 3, 4, 5, 6, 7, 6, 7, 8, 9, 10 };
	int arr2[20] = { 0 };
	//将arr1的内容拷贝到arr2中
	memcpy(arr2, arr1, 40);
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

运行结果：

（2）浮点型的拷贝：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
 
int main()
{
	float arr1[] = { 1.0, 2.0, 3.0 ，4.0};
	float arr2[5] = { 0 };
	//将arr1的内容拷贝到arr2中
	memcpy(arr2, arr1, 8);
	//   float*  float*
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%f ", arr2[i]);
	}
	return 0;
}

2.memcpy函数的模拟实现：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
 
void* my_memcpy(void* dest, const void* src, size_t num)//num的单位是字节
{
	void* ret = dest;
	assert(dest && src);
	while (num--)
	{
		*(char*)dest = *(char*)src;//char*是最小的指针一次拷贝一个字节
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}
 
 
int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int arr2[20] = { 0 };
	my_memcpy(arr2, arr1, 20);
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

由此可知memcpy函数是用来处理 不重叠的内存拷贝的。

那有没有什么函数可以重叠拷贝？下边将介绍memmove函数

2.memmove的使用以及模拟实现

1.memmove的使用

（1）简单理解：

仔细看的话能看出和memcpy参数一模一样，用法也一模一样

• 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
• 如果源空间和目标空间出现重叠，就得使用memmove函数处理。

2）memmove的使用：

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

运行结果：

2.memmove的模拟实现

数组随着下标的增长地址由高到低变化 

重叠拷贝分三种情况：

① 从前往后，如果这时候从后往前拷贝7时会把6覆盖掉，拷贝6是把5给覆盖掉...

②从后往前，如果这时候从前往后3会覆盖掉4...和上面情况相似

③从前往后，从后往前都行，因为两个数组不起冲突

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
 
void* my_memmove(void* dest, void* src, size_t num)
{
	void* ret = dest;
	assert(dest && src);
	if (dest < src)
	{
		//前 -> 后
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		 }
	}
	else
	{
		//后 -> 前
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
		
	}
	return ret;
}
 
int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	my_memmove(arr1 , arr1 + 2, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

运行结果：

 总结：重叠的内存拷贝交给memmove来做，memmove 当然也可以拷贝不重叠的拷贝