内存操作函数

1.memcpy

memcpy:拷贝字符到缓冲区

void* memcpy(void*  dest,const void*  src,size_t  count);

注：count为拷贝字节的个数

memcpy函数在实现的时候，不知道未来会被用来拷贝什么类型的数据，所以用void*的指针接收是比较合适的！

 

memcpy的模拟实现

//memcpy的模拟实现
#include<assert.h>
void* my_memcpy(void* dest,const void* src, size_t count)
{
	assert(dest && src);
	void* ret = dest;
	while (count--)
	{
		*(char*)dest = *(char*)src;
		((char*)dest)++;//空类型的指针不能++，所以强转成char*指针，又因为++优先级较高，所以先括起来再++
		((char*)src)++;
	}
	return ret;
}
int main()
{
	int arr1[10] = { 1, 2, 3, 4, 5, 6 };
	int arr2[20] = { 0 };
	my_memcpy(arr2, arr1, 16);
	return 0;
}

memcpy是用来拷贝不相关的内存块的，若内存重叠，则无法拷贝！

 

重叠拷贝示例如下

//重叠拷贝
int main()
{
	int arr[20] = { 1, 2, 3, 4, 5, 6, 7, 8, 9,10 };
	memcpy(arr + 2, arr, 16);
	return 0;
}

注：然而我们在vs下发现memcpy可以实现重叠拷贝（模拟实现的my_memcpy就不行），但标准规定中memcpy只用实现不重叠拷贝就行，因此重叠拷贝还是需要用memmove。

 

2.memmove

(可进行重叠拷贝)

//memmove函数(可实现重叠拷贝)
int main()
{
	int arr[20] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	memmove(arr + 2, arr, 16);//memmove可重叠拷贝
	return 0;
}

如图所示

以指针src为分界线

若dest在src右边，则从后向前拷贝

若dest在src左边，则从前向后拷贝

若src和dest所指向的两个内存块不相关（不重叠），则拷贝顺序无所谓

有了以上结论后，我们就可以模拟实现memmove。

 

memmove的模拟实现

//memmove模拟实现
void* my_memmove(void* dest, void* src, size_t count)
{
	void* ret = dest;
	if (dest < src)
	{
		//从前向后
		while (count--)
		{
			*((char*)dest) = *((char*)src);
		}
	}
	else
	{
		//从后向前
		while (count--)
		{
			*((char*)dest + count) = *((char*)src + count);//此代码传进函数的count=16，第一次进入循环后count=15，指针首地址加15刚好指向末尾
		}
	}
	return ret;
}
int main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	my_memmove(arr + 2, arr, 16);
	return 0;
}

 

3.memcmp

字符比较函数

int  memcmp(const void*  buf1,const void*  buf2,size_t  count);

注：count为要比较的字节数

返回结果：

<0     buf1  less  than  buf2

=0     buf1  identical  to  buf2

>0     buf1  greater  than  buf2

//memcmp函数(比较字符函数)
int main()
{
	int arr1[] = { 1, 2, 3, 4, 5 };
	int arr2[] = { 1, 2, 4, 6, 7 };
	int ret = memcmp(arr1, arr2, 8);//比较字节数为8，即比较前两个数字，相等，所以返回0
	printf("%d\n", ret);
	return 0;
}

int main()
{
	int arr1[] = { 1, 2, 3, 4, 5 };//01 00 00 00 02 00 00 00 03 00 00 00
	int arr2[] = { 1, 2, 4, 6, 7 };//01 00 00 00 02 00 00 00 04 00 00 00
	int ret = memcmp(arr1, arr2, 9);
	printf("%d\n", ret);//-1
	return 0;
}

 

4.memset

//memset
int main()
{
	char arr[10] = { 0 };
	memset(arr, '*', 10);
	return 0;
}

需要注意的是，这个函数第三个参数是字节数，因为上面的例子是一个字符数组，因此修改10个字节刚好就将字符数组中的10个元素改掉，来看看下面的易错例子

//memset易错例子
int main()
{
	int arr[10] = { 0 };
	memset(arr, 1, 40);
	return 0;
}

按理来说，arr是个有10个元素的整型数组，我们应该是把arr中的10个元素都改成了1，但是事实并非如此，我们看到每个元素都是很大的数，为什么呢，这是因为上面已经提到了，memset会把每个字节都修改，因此内存中的每个元素应该是从00 00 00 00修改成01 01 01 01，将这个十六进制数0x01010101转换成十进制后就会变成一个很大的数。

我们把这个很大的数进行16进制转换可以看到

因此使用这个函数时要加倍小心，它会将每个字节上的内容都修改！