C语言内存函数

memcpy<string.h>

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

1. 从source的位置开始向后复制num个字节的数据到destination指向的内存为止
2. memcpy不会遇见\0停止
3. 如果source和destination有任何的重叠，复制的结果都是未定义的
4. num单位是字节

1. 函数拷贝后，会返回目标空间的起始地址
2. char * 类型指针解引用访问一个字节，所以将其强制类型 转化为char *

memmove

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

1. 和memcpy的差别是，memmove的源内存和目标内存块是可以重叠的
2. 如果源空间和目标空间出现重叠，就得使用memmove函数处理
3. 拷贝完后，会返回目标空间的起始地址
4. 在实现拷贝的时候，有些情况需要由前向后拷贝，有些情况需要向后向前拷贝
5. 因为当空间出现重叠时，拷贝时会将值赋值了，所以拷贝的不是原来的值，而是赋值后的值

1. 将1,2,3,4,5 20个字节复制到3,4,5,6,7的位置——1,2,1,2,3,4,5,8,9,10
2. 但如果从前往后复制，1,2赋值到了3,4的位置，需要将3赋值到5时，3却已经被赋值为1，所以会将1赋值到3，所以从前往后复制是行不通的

重叠时如何拷贝

1. 当dest落在src左边时，从前向后拷贝

2. 

3. 当dest落在src右边时，从后向前拷贝
4. 方式一：落在src前面，从前——后；落在src后面，从后——前
5. 方式二：只有落在src后面，从后——前，其余都是从前——后

使用

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

模拟实现

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
void* my_memmove(void* dest, void* src, size_t num)
{
	void * ret = dest;
	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 arr[20] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr + 2, arr, 5 * sizeof(int));
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

memset函数的使用

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

设置内存的函数，将内存中的值以字节为单位设置成想要的内容

ptr指向填充的内存块

value你要填充的值

num字节

如果想将每个元素设置为1，memset(arr,1,20)这样写是错误的，函数是以字节为单位设置的，他会将每个字节设置为1 ，不是将每个元素设置为1

memcmp

内存块的比较

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

比较从ptr1和ptr2指针指向的位置开始，向后的num个字节

比前16个字节，也就是前四个元素，返回值为0——相等

比前17个字节，返回值为-1——小于