内存函数（memcpy,memmove,memcmp,memset）

memcpy

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

int arr1[10]={1,2,3,4,5,6,7,8,9,10};
int arr2[20]={0};
memcpy(arr2,arr1,20);
//最后arr2:1,2,3,4,5,0,0,0,0,0,...

因为是拷贝的内存的数据，所以什么类型都可以，用 void.*

模拟实现memcpy

#include<stdio.h>
#include<string.h>
#include<assert.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;
		src = (char*)src + 1;
	}
	return ret;
}

说明：
memcpy应该拷贝不重叠的内存
比如：

int arr[10]={1,2,3,4,5,6,7,8,9,10};
my_memcpy(arr+2,arr,20);
//按理说应该是1 2 1 2 3 4 5 8 9 10
//可是实际上是1 2 1 2 1 2 1 8 9 10

但是，memmove可以处理内存重叠情况

memmove

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

int arr[10]={1,2,3,4,5,6,7,8,9,10};
memmove(arr+2,arr,20);
//1 2 1 2 3 4 5 8 9 10

模拟实现memmove

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

说明：
但是可以看到，在VS-2013中，用memcp可以实现重叠拷贝
原因：规定memcpy 只要实现了不重叠拷贝就可以了
而VS-2013中实现既可以实现重叠也可以实现不重叠

memcmp

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

float arr1[] = { 1.0,2.0,3.0,4.0 };
float arr2[] = { 1.0,3.0 };
int ret = memcmp(arr1, arr2, 8);
//memcmp--strcmp
printf("%d\n", ret);

memset

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

把ptr所指向的那块空间前的num字节设置成指定值value.
以字节为单位设置内存

int arr[10]={0};
memset(arr,1,20);
//01010101
//01010101
//01010101
//01010101
//00000000
//00000000
//00000000
..........