内存函数们的使用和实现

memcpy

一、使用

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

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

memcpy是做内存拷贝的，拷贝的可能是字符串，可能是整形数组，可能是结构体也可能是其他类型

内存函数针对内存怀，不在乎内存中的数据

二、实现

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

参数：destination：终点        sourse：源头     num：字节数

返回的为目标空间的起始地址

#include<assert.h>
#include<stdio.h>
void my_memcpy(void* dest, const void* src, size_t num)
{
	void* ret = dest;
	assert(dest && src);
	while (num)
	{
		*(char*)dest = *(char*)src;   //拷贝一个字节
		dest = (char*)dest + 1;       //强转具有临时性，不能直接dest++
		src = (char*)src + 1;
		num--;
	}
	return ret;
}
int main()
{
	int arr1[10] = { 0 };
	int arr2[] = { 1,2,3,4,5,6,7,8 };
	my_memcpy(arr1, arr2, 20);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

tips：也可为：

++（char*）dest；
++（char*）src；

但是有些编译器上跑不起来，即不识别该语法（不认可具有临时性变量的++/--）

例二：

#include<assert.h>
#include<stdio.h>
void my_memcpy(void* dest, const void* src, size_t num)
{
	void* ret = dest;
	assert(dest && src);
	while (num)
	{
		*(char*)dest = *(char*)src;   //拷贝一个字节
		dest = (char*)dest + 1;       //强转具有临时性，不能直接dest++
		src = (char*)src + 1;
		num--;
	}
	return ret;
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memcpy(arr+2, arr, 20);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

你觉得输出结果是什么捏？

是不是以为输出结果应该是：1 2 1 2 3 4 5 8 9 10

然鹅结果却是：1 2 1 2 1 2 1 8 9 10

为什么捏？

其实，随着拷贝的进行，3位变成1,4位变成2,在拷贝的时候也为1,2

memcpy可处理不重叠内存的数据拷贝

内存之间如果有数据重叠，可以使用memmove函数

memmove 

一、使用

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

二、实现

研究memmove函数的实现：

分情况讨论一哈：

如果是这种情况，我们可以尝试从后向前拷贝，但在另一种情况下：

从后向前又变得不可行，此种情况下，应从前向后拷贝

具体实现代码：

#include<assert.h>
#include<stdio.h>
void* my_memmove(void* dest, const 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;
}

在判断条件处，还可写为：

if(dest>=src&&dest<=(char*)src+num)
{
   //后->前
}
else
{ 
   //前->后
}

图解：

其实，库里的memcpy可以拷贝重叠的内存

为什么捏？

memcpy函数只要能处理内存不重叠的拷贝就行，可以将重叠的情况交给memmove函数

但是我们发现有时标准库中的memcpy也能实现重叠拷贝，但这不代表所有编译器实现的标准库中的memcpy都能实现重叠拷贝，总结起来就是：VS牛波一！！！！超额完成任务！！！！

memset 

使用

memset内存初始化函数

例：

#include<string.h>
#include<stdio.h>
int main()
{
	char arr[] = "hello world!";
	memset(arr, 'x', 5);
	printf("%s\n", arr);
	return 0;
}

应该懂了吧。。。烤烤你：

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

输出结果是什么？

 被唬到了吗。。？

memset的设置1，是把内存中的每个字节都设置为1，memset以字节为单位设置内存值

memcmp

使用

#include<string.h>
#include<stdio.h>
int main()
{
	int arr1[] = { 1,3,5,7,9 };
	int arr2[]= {1,0x12345603,3,4,5};
	int ret = memcmp(arr1, arr2, 5);
	printf("%d\n", ret);
	return 0;
}

按字节比较