c语言16-动态内存malloc、内存申请函数及泄露检测、calloc、realloc、free崩溃原因

1、动态内存使用场景

使用动态内存的原因

1）需要大内存；
2）需要根据变量动态开辟内存；
3）…

动态内存和静态数组：

动态内存：

存放在堆（heap），很大（超过1.5G），申请的是连续的内存，可能导致申请不成功
测试：
测试钱内存使用情况：

运行测试代码：

程序成功运行：

运行后内存使用情况：

程序停止后内存使用情况：

当然不能申请太大：
申请失败：

申请成功：

静态数组（int arr[10];）：

放在栈（stack），很小，1M
测试：
程序崩溃：

开辟内存：malloc，calloc（置0），realloc（扩容）

释放内存：free；

如果不释放内存，会出现内存泄露；

void *：

通用地址，记录地址，其中的数据类型并不知道，没有类型信息；

代码：

//筛选法求素数
void Fun(int n)
{
	//int arr[n];//标记，error，数组定义是长度为常量
	//int arr[10000000];//bug
	int *arr =(int *)malloc(n*sizeof(int));//申请的字节,申请n个整型单元，做标记

	int i;

	for(i=0;i<n;i++)
	{
		arr[i]=1;
	}

	arr[0] = arr[1] =0;

	for(i=2;i<n;i++)//筛选法
	{
		for(int j=i+1;j<n;j++)
		{
			if(j%i == 0)//j是i的倍数，j不是素数
			{
				arr[j]=0;//标记改为0，不是素数
			}
		}
	}

	for(i=2;i<n;i++)
	{
		if(arr[i]==1)//是素数
		{
			printf("%d\n",i);
		}
	}

}


int main()
{
	Fun(10);
	printf("\n");
	Fun(20);
	printf("\n");
	Fun(100);

	return 0;
}

运行结果：

动态申请10个整型单元

	int n = 10;
	int *p1 = (int *)malloc(n*sizeof(int ));

关于判断申请是否成功问题

	int n = 10;
	int *p1 = (int *)malloc(n*sizeof(int ));

	assert(p1!=NULL);

看个人喜欢，一般不会申请失败，

2、内存申请函数及泄露检测

泄露内存被回收的情况：

1、程序（进程）退出；
2、重启

free的使用

int main()
{
	int n = 10;
	int *p1 = (int *)malloc(n*sizeof(int ));

	for(int i=0;i<n;i++)
	{
		p1[i] = i;
	}

	for(int i=0;i<n;i++)
	{
		printf("%d ",p1[i]);
	}

	free(p1);//释放内存

	return 0;
}

使用很简单，问题是比较容易忘记，

检查辅助工具：#include <vld.h>

#include <vld.h>

然后启动调试：

存在内存泄露时：

int main()
{
	int n = 10;
	int *p1 = (int *)malloc(n*sizeof(int ));

	for(int i=0;i<n;i++)
	{
		p1[i] = i;
	}

	for(int i=0;i<n;i++)
	{
		printf("%d ",p1[i]);
	}

	//free(p1);//释放内存

	return 0;
}

没有内存泄露时：

int main()
{
	int n = 10;
	int *p1 = (int *)malloc(n*sizeof(int ));

	for(int i=0;i<n;i++)
	{
		p1[i] = i;
	}

	for(int i=0;i<n;i++)
	{
		printf("%d ",p1[i]);
	}

	free(p1);//释放内存

	return 0;
}

3、calloc()函数

申请内存，并将每个元素置为0；

代码使用：

int main()
{
	int n = 10;
	int *p1 = (int *)malloc(n*sizeof(int ));
	
	for(int i=0;i<n;i++)
	{
		printf("%d ",p1[i]);
	}

    printf("\n");

	for(int i=0;i<n;i++)
	{
		p1[i] = 0;
	}

	for(int i=0;i<n;i++)
	{
		printf("%d ",p1[i]);
	}

	printf("\n");

	int *p2 = (int *)calloc(n,sizeof(int ));

	for(int i=0;i<n;i++)
	{
		printf("%d ",p1[i]);
	}

	free(p1);//释放内存
	free(p2);

	return 0;
}

运行结果：

4、realloc()函数

对动态内存进行扩容

只使用malloc对内存进行扩容：

int main()
{
	//动态申请10个整型
	int n = 10;
	int *p1 = (int *)malloc(n*sizeof(int ));

	assert(p1!=NULL);

	//int i;
	//模拟使用p

	/*for(int i=0;i<20;i++)//程序崩溃
	{
		p1[i] = 0;
	}*/
	for(int i=0;i<10;i++)
	{
		p1[i] = 0;
	}

	//p的内存不足，需要扩容
	int *p2 = (int *)malloc(2*n*sizeof(int ));

	for(int i=0;i<n;i++)
	{
		p2[i] = p1[i];
	}

	free(p1);
	p1 = p2;
	p2 = NULL;

	//后面可以继续使用p1，且p1的内存大小为2n个int单元

	for(int i=0;i<20;i++)
	{
		printf("%d ",p1[i]);
	}

	return 0;
}

使用realloc进行扩容

int main()
{
	//动态申请10个整型
	int n = 10;
	int *p1 = (int *)malloc(n*sizeof(int ));

	assert(p1!=NULL);

	for(int i=0;i<10;i++)
	{
		p1[i] = 0;
	}

	p1 = (int *)realloc(p1,2*n*sizeof(int ));//一般来说 ，扩容后p1的地址不一样

	for(int i=0;i<20;i++)
	{
		printf("%d ",p1[i]);
	}

	free(p1);

	return 0;
}

注：一般来说 ，扩容后p的地址不一样

5、free崩溃原因

动态内存在申请的时候，会存储一个头、尾信息，所以当你申请一定空间后，会额外使用一些空间用于存储相关信息。头、尾信息一方便在释放内存的时候知道释放内存的大小、头和尾。以方便系统对内存进行回收。尾信息用于内存合并的时候起到一个“胶水“的作用，以处理内存碎片。

free崩溃的情况：

动态内存块有头和尾，如果破坏其中一个free时就会崩溃；

1）越界（较多）

代码示例：

int main()
{
	//动态申请10个整型
	int n = 10;
	int *p = (int *)malloc(n*sizeof(int ));//漏写sizeof，也会造成越界崩溃

	//for(int i=0;i<n;i++)
	//{
	//	p[i] = 0;
	//}

	for(int i=0;i<=n;i++)//越界，会崩溃
	{
		p[i] = 0;
	}

	for(int i=0;i<n;i++)
	{
		printf("%d ",p[i]);
	}

	free(p);

	return 0;
}

运行结果：

2）指针移动，++，–（找不到头）

int main()
{
	//动态申请10个整型
	int n = 10;
	int *p = (int *)malloc(n*sizeof(int ));


	for(int i=0;i<n;i++)
	{
		//p[i] = 0;//ok
		*p = 0;
		p++;//指针移动，会出现崩溃
	}

	for(int i=0;i<n;i++)
	{
		printf("%d ",p[i]);
	}

	free(p);

	return 0;
}

运行结果：

指针被移动，将头信息破坏了。

3）重复释放同一个内存

一般是不小心将两个指针指向同一个内存，然后不小心释放两次。

int main()
{
	int *p = (inr *)malloc(20);
	int *q = p;
	free(p);
	free(q);

	return 0;
}