C语言内存函数

内存函数

memcpy 内存拷贝

memcpy 函数参数

void * memcpy ( void * destination, const void * source, size_t num );

• mencpy 第一个参数是要将拷贝的内容存放的地址， 第二个参数是拷贝内容的地址，第三个参数是拷贝的字节个数
• mencpy 应该拷贝不重叠的内存，vs2022 上 memcpy 是可以实现空间重复拷贝的，有些编译器上是实现不了空间重叠拷贝
• memcpy 在遇到 ‘\0’ 的时候并不会停下来，只会拷贝 num 个结束
• memcpy 拷贝是以字节为单位

memcpy 函数使用
arr 拷贝5个元素到 arr2 中

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

结果：

memmove 内存重叠拷贝

memmove 函数参数

 void * memmove ( void * destination, const void * source, size_t num );

• 从参数可以看出，和memcpy 是一模一样，不过memcpy 是不能处理重叠的情况
• memcmp 是用来处理果源空间和目标空间重叠的情况

memmove 函数使用

#include<string.h>
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;
}

结果：

memcmp 内存比较

memcmp 函数参数

int memcmp ( const void * ptr1,  const void * ptr1,  size_t num );

• memcmp 和 strcmp 类似，都是比较函数，不过memcmp 比价的是内存
• 使用的方法和 strcmp 是一样的

memcpy 函数使用

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int str[10] = { 1,2,3,2,2,9,8,9 };
	int ret = memcmp(arr, str, 20);
	if (ret > 0)
		printf("arr > str\n");
	else if (ret < 0)
		printf("arr1 < str\n");
	else
		printf("arr1 == str\n");

	return 0;
}

memset 内存设置

memset 函数参数

void * memset ( void * ptr, int value, size_t num );

• 第一·个参数：设置空间的地址
  第二个参数：设置参数
  第三个参数：把num个参数改为 第二个参数的值
• 是把 ptr里的 num 个字节的空间，改为 value

memset 函数使用

int main()
{
	int arr[10] = { 0 };
	memset(arr, 1, 8);

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

结果：

• 上面的函数是对每个字节改成 1
  每个整形元素是 4 个字节，把所有的元素改成1
  
  咱用计算器计算一下，这个数值是多少
  
  对比一下：
  

模拟 memcpy 内存拷贝

实现代码：
重点注意：

• 函数的参数和放回参数应该设置成 void* 类型
• 函数是以字节为单位进行拷贝，所以要强制转换成 char* 类型

void* my_memcpy(void* dest,const void * str,size_t num)
{
	int* s = dest;
	while (num--)
	{
		*(char*)dest = *(char*)str;
		dest = (char*)dest + 1;
		str = (char*)str + 1;
	}
	return s;
}

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

模拟 memover 内存重叠拷贝

代码实现：

#include<assert.h>
void* my_memmove(void* dest, const void* str, size_t num)
{
	void* s = dest;
	assert(dest && str);
	if (dest < str)
	{
		while (num--)
		{
			//前 -> 后
			*(char*)dest = *(char*)str;
			dest = (char*)dest + 1;
			str = (char*)str + 1;
		}
	}
	else
	{
	    //后 -> 前
		while (num--)
		{
			*((char*)dest + num) = *((char*)str + num);
		}
	}
	return s;
}
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;
}

模拟 memcmp 内存比较

代码实现：

• 代码实现的思想和 strncmp 是差不都的

int my_memcmp(const void* ptr, const void* ptr2,size_t num)
{
	while (num--)
	{
		if (*(char*)ptr < *(char*)ptr2)
			return -1;
		else if (*(char*)ptr > *(char*)ptr2)
			return 1;
	}
	return 0;
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8 };
	int str[] = { 1,2,3,8,9 };
	int ret = memcpy(arr, str, 20);
	if (ret > 0)
		printf("arr > str\n");
	else if (ret < 0)
		printf("arr1 < str\n");
	else
		printf("arr1 == str\n");
}

这章主要讲的是内存函数和使用，后面会尝试模拟实现，今天的就讲完了，不错点个赞