简单易懂的内存函数的使用

目录

1.memcpy

2.memmove

3.memcmp

4.malloc

5.free

6.calloc 

7.realloc

---

1.memcpy

该函数用来source的位置开始向后复制count个字节的数据到destination的内存位置（和上一篇字符串函数的strcpy类似）

该函数遇到'\0'的时候不会停下来

如果source和destination有任何的重叠,其结果都是未定义的

#include<stdio.h>
#include<string.h>
int main()
{
	char arr1[]="abcdef";
	char arr2[30]={0};
	memcpy(arr2,arr1,6);
	printf("%s\n",arr2);
	return 0;
}

运行结果:

模拟实现memcpy 

#include<stdio.h>
#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;//要复制的是字符类型的，将void*类型转换为char*类型
		((char*)dest)++;
		((char*)src)++;
	}
	return ret;
}
int main()
{
	char arr1[]="abcdef";
	char arr2[30]={0};
	my_memcpy(arr2,arr1,6);
	printf("%s\n",arr2);
	return 0;
}

2.memmove

memmove和 memcpy 的差别就是 memmove 函数处理的源内存块和目标内存块是可以重叠的

如果源空间和目标空间出现重叠，就得使用 memmove 函数处理

但在当前VS2019版本下已将memcpy实现的和memmove这个函数没什么差别了,所以不会出现source和destination有任何的重叠,其结果都是未定义的这种情况

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

运行结果：

模拟实现memmove

#include<stdio.h>
#include<assert.h>
void* my_memmove(void* dest, const void* str, size_t count)
{
	assert(dest && str);
	char* ret = dest;
	if (dest <= str)//如果目标地址小于源头地址则从低地址到高地址复制防止数据被覆盖
	{
		while (count--)
		{
			*(char*)dest = *(char*)str;
			dest = (char*)dest + 1;
			str = (char*)str + 1;
		}
	}
	else//如果目标地址大于源头地址则从高地址到低地址复制
	{
		while (count--)
		{
			*((char*)dest + count) = *((char*)str + count);
		}
	}
	return ret;
}
int main()
{
	int arr[] = { 0,1,2,3,4,5,6,7,8,9 };
	my_memmove(arr + 4, arr + 2, 20);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

 3.memcmp

 用来比较从buf1和buf2开始的count个字节

 

#include<stdio.h>
#include<string.h>
int main()
{
	char arr1[] = "abd";
	char arr2[] = "abc";
	int ret = memcmp(arr1, arr2, strlen(arr1));
	printf("%d\n", ret);
	return 0;
}

 运行结果：

模拟实现memcmp

#include<stdio.h>
#include<string.h>
#include<assert.h>
int my_memcmp(char* buf1, char* buf2, size_t count)
{
	assert(buf1 && buf2);
	if (!count)
		return(0);
	while (--count && *buf1 == *buf2)//相等时
	{
		buf1++;
		buf2++;
	}
	return(*buf1 - *buf2);//不相等的时候返回两个字符的ASCLL的差值
}
int main()
{
	char arr1[] = "abd";
	char arr2[] = "abc";
	int ret = my_memcmp(arr1, arr2, strlen(arr1));
	printf("%d\n", ret);
	return 0;
}

 4.malloc

这个函数向内存申请一块 连续可用 的空间，并返回指向这块空间的指针。

如果 开辟成功 ，则返回一个指向开辟好空间的指针。

如果 开辟失败 ，则返回一个 NULL 指针，因此 malloc 的返回值一定要做检查。

返回值的类型是 void* ，所以 malloc 函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。

如果参数 size 为  0 ， malloc 的行为是标准是未定义的，取决于编译器。

#include<stdio.h>
#include<stdlib.h>
int main()
{
	char* p = malloc(40);
	free(p);//释放内存防止内存泄露
	return 0;
}

 5.free

free 函数用来 释放动态开辟的内存 。

如果参数 ptr 指向的空间不是动态开辟的，那 free 函数的行为是未定义的。

如果参数 ptr 是 NULL 指针，则函数什么事都不做。

6.calloc 

函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。

与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全 0 。

#include<stdio.h>
#include<stdlib.h>
int main()
{
	char* p = calloc(20,sizeof(int));
	free(p);
	return 0;
}

7.realloc

realloc 函数的出现让动态内存管理更加灵活。

有时候申请的空间太小了，有时候申请的空间过大了，那为了合理的内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。

 

 memblock是要调整的内存地址

size是调整之后新大小

返回值为调整之后的内存起始位置。

这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间。

#include<stdio.h>
#include<stdlib.h>
int main()
{
	char* p = malloc(20);
	realloc(p, 40);//扩大一倍
	free(p);
	return 0;
}

realloc 在调整内存空间的是存在两种情况：

情况 1 ：原有空间之后有足够大的空间

情况2：原有空间之后没有足够大的空间

 

情况 1

当是情况 1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。

情况 2

当是情况 2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小

的连续空间来使用。这样函数返回的是一个新的内存地址。