动态内存分布——malloc,calloc,realloc,free的使用。以及关于动态内存的常见错误。

我们知道内存的使用方式,可以在栈区,静态区,堆区,申请空间来储存变量。

但是他们这些内存区所存储的东西是不一样的。

局部变量

函数的形式参数

栈区

动态内存分配申请的空间

malloc,calloc,realloc,

堆区

全局变量,

静态变量,

static修饰的变量

静态区

创建一个变量:

int a=10;int arr[]={0};——局部变量——栈区;

int a=10;int arr[]={0};——全局变量——静态区;

但是面两种申请的空间都是固定的,例如我们在使用数组的时候,有时候发现数组的申请的空间小了,又回去改数组的大小,改了之后又发现用不完,就回给我们的空间造成浪费,数组而不能达到随心所欲的修改申请给我们带来不便。这就是我们今天学习的动态内存分布就可以很好的解决相这个问题,当我们的申请的空间小了,我们可以直接扩充,用不完的可以直接减少。

1.malloc

头文件: #include

函数框架:void*malloc(size_t size)。

返回值:函数的返回类型位空指针类型,可根据具体的申请的和需要强行转换指针类型,返回的指针指向申请的空间的是首地址。

参数:函数的参数是一个无符号整型数字(size_t  size),代表申请空间的大小,单位为字节。

如果申请成功函数返回申请在堆区空间的地址,如果申请不成功,就会返回NULL(空指针)。

实例:

#include
#include
int main()
{
	int* p = (int*)malloc(sizeof(int) * 10);//申请了一个可以存放10个int类型的空间;
	if (p == NULL)//判断是否申请失败,申请失败会返回空指针(NULL).
	{
		printf("申请失败\n");
	}
	else
	{
		printf("申请成功\n");
	}
	return 0;
}

 这里申请成功了

动态内存分布——malloc,calloc,realloc,free的使用。以及关于动态内存的常见错误。_第1张图片

 让我们看一下申请不成功的情况

#include
#include
int main()
{
	int* p = (int*)malloc(100000000000000000*10000000000000000000);//申请了一个非常大的空间,
																   //已经超出我们堆区的最大存储空间,
																   //肯定会申请失败;
	if (p == NULL)//判断是否申请失败,申请失败会返回空指针(NULL).
	{
		printf("申请失败\n");
	}
	else
	{
		printf("申请成功\n");
	}
	return 0;
}

接下来我们看一下malloc申请空间的使用:

看代码:

#include
#include
int main()
{
	int* p = (int*)malloc(sizeof(int)*10);//申请可以存放10个int型变量的空间;
	if (p == NULL)//判断是否申请失败,申请失败会返回空指针(NULL).
	{
		printf("申请失败\n");
		return 0;//如果申请失败,我们程序就直接退出,因为申请失败也没有必要进行操作;
	}
	else
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(p + i) = i;//申请的10个空间,赋值0——9;
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p+i));//证明我们我们的数字已经存进去,打印出我们存进去的数字。
	    }
	}
	free(p);//当我们的动态申请的空间不再使用的时候,就应该还给操作系统,所以就是用free,对申请的空间释放。
	p = NULL;//但是我们申请的空间是还给操作系统了,但是指针 p 仍旧可以找到那块空间,所以我们把 p赋值成空指针,将指针 p 与空间完全断开联系。
	          
	return 0;
}

关于free:

malloc与free,是成对使用的。 

2.calloc

头文件:#include

函数框架:void*calloc(size_t num,size_t size);

calloc的功能与malloc基本一样,也是从堆区申请一块空间,但是区别就在于calloc会在返回地址之前把申请的空间全部赋值为0;

参数:size_t num——无符号整形数,代表申请空间的个数,size_t size——无符号整形数,代表

申请每个空间的大小,单位为字节。

返回值:函数的返回类型位空指针类型,可根据具体的申请的和需要强行转换指针类型,返回的指针指向申请的空间的是首地址。

如果申请成功函数返回申请在堆区空间的地址,如果申请不成功,就会返回NULL(空指针)。

实例2.

#include
#include
int main()
{
	int* p = (int*)calloc(10,sizeof(int));//申请可以存放10个int型变量的空间;
	if (p == NULL)//判断是否申请失败,申请失败会返回空指针(NULL).
	{
		printf("申请失败\n");
		return 0;//如果申请失败,我们程序就直接退出,因为申请失败也没有必要进行操作;
	}
	else//申请成功开始使用
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));//查看在为赋值的时候申请的空间里面存储是不是0;
			*(p + i) = i;//申请的10个空间,赋值0——9;
		}
		printf("\n");
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));//证明我们的数字已经存进去,打印出我们存进去的数字。
		}
	}
	free(p);
	p = NULL;//用完别忘记释放哦。
	return 0;
}

3.realloc

realloc函数使我们动态内存管理更加灵活。

有时会发现过去申请的空间太小了,有时候我又会觉得申请的空间太大了,那为了合理的内存,我们呢一定会对内存进行灵活的调整,realloc就可以做到对内存大小的调整。

函数原型:void* realloc(void*ptr,size_t size)

参数:void*ptr ,ptr为要调整的空间的地址,size_t size为调整之后的新大小。

返回值:调整之后的内存的起始位置,

函数在调整原内存空间大小的基础上,还会将原来内存中的数据移动到新的空间里面去。

realloc使用实例:

#include
#include
int main()
{
	int* p = (int*)calloc(10, sizeof(int));//申请可以存放10个int型变量的空间;
	if (p == NULL)//判断是否申请失败,申请失败会返回空指针(NULL).
	{
		printf("申请失败\n");
		return 0;//如果申请失败,我们程序就直接退出,因为申请失败也没有必要进行操作;
	}
	else//申请成功开始使用
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));//查看在为赋值的时候申请的空间里面存储是不是0;
			*(p + i) = i;//申请的10个空间,赋值0——9;
		}
		printf("\n");
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));//证明我们的数字已经存进去,打印出我们存进去的数字。
		}
	}
	printf("\n");
	//这时我们发现内存不够
	int* p1 = (int*)realloc(p, sizeof(int) * 15);//我们将申请空间扩大到可以存放15个int型数字。
	if (p1 == NULL)
	{
		printf("申请失败");
		return 0;
	}
	for (int i = 10; i < 15; i++)
	{
		*(p1 + i) = i;//将新申请的空间赋值10——14;
	}
	for (int i = 0; i < 15; i++)
	{
		printf("%d ", *(p1 + i));
	}
	free(p1);
	p1 = NULL;

	return 0;
}

关于realloc的注意:

如果原空间之后有足够的空间就可以直接追加,然后返回调整之后的空间的起始位置地址;

如果原空间后面没有足够的空间可以用来追加,则realloc就会重新找一个新的内存区域,将元数据拷贝过去再追加,最后返回新空间的起始位置地址;

要用一个新的指针变量来接受realloc函数的返回值;

关于realloc在内存追加空间的时候,后面没有足够的大小用来追加会重新找一个新的内存区域,将元数据拷贝过去再追加,最后返回新空间的起始位置地址;

实例:

#include
#include
int main()//(1)后面有足够的空间追加;
{
	int* p = (int*)malloc(1);//申请可以存放1个字节的空间;
	if (p == NULL)//判断是否申请失败,申请失败会返回空指针(NULL).
	{
		printf("申请失败\n");
		return 0;//如果申请失败,我们程序就直接退出,因为申请失败也没有必要进行操作;
	}
	printf("%p\n", p);
	int* p= (int *)realloc(p, 2);//追加一个字节,后共2个字节;
	printf("%p\n", p);
	free(p);
	p=NULL;
	return 0;
}

#include
#include
int main()//(1)后面没有足够的空间追加;
{
	int* p = (int*)malloc(1);//申请可以存放1个字节的空间;
	if (p == NULL)//判断是否申请失败,申请失败会返回空指针(NULL).
	{
		printf("申请失败\n");
		return 0;//如果申请失败,我们程序就直接退出,因为申请失败也没有必要进行操作;
	}
	printf("%p\n", p);
	int* p= (int *)realloc(p, 10000);//追加字节,后共10000个字节;
	printf("%p\n", p);
	free(p);
	p=NULL;
	return 0;
}

动态内存分布——malloc,calloc,realloc,free的使用。以及关于动态内存的常见错误。_第2张图片

常见的动态内存的错误

1.对空指针解引用

void test()
{
	int* p = (int*)malloc(1000000000 * 10000000*10000000);//由于申请的空间过大而申请失败返回空指针;
	*p = 20;//当p为NULL时就会有问题;
	free(p);
	p = NULl;

}

2.对动态开辟的空间越界访问

int* p = (int*) = malloc(sizeof(int) * 5);//申请5个int的空间
if (p = NULl)
{
	exit;
}
for (int i = 0; i < 10; i++)//却访问10个int的空间
{
	*(p + i) = i;
}

3.对非动态开辟的空间进行free释放

void test()
{
	int a = 10;
	int* P = &a;
	free(p);//OK?
}

4.使用free释放一块空间的一部分

void Get()
{
	int*p = (char*)malloc(100);
	p++;
	free(p);//p不在指向动态内存的起始位置;
}

5.对同一块动态内存多次释放

void Get()
{
	int*p = (char*)malloc(100);
	free(p);
	free(p);
}

6.动态内存忘记释放

7.

void Get(char* p)
{
	p = (char*)malloc(100);
}
void test()
{
	char* str = NULL;
	Get(str);//以变量的方式传参;无法做到str的修改;
	strcpy(str, "hello");
	printf(str);
}

运行的时候程序会崩溃,而且存在内存泄漏;

str以值的形式传参给p;p是Get的函数的形参,只能在函数内部有效,等Get函数返回之后,动态开辟的空间还未释放,并且无法找到,就会存在内存泄漏。

你可能感兴趣的:(c语言)