C语言学习第10天堆内存

什么是堆内存：
是进程的一个内存段(text\data\bss\heap\stack),是由程序员手动管理的
特点：足够大 缺点：使用麻烦

为什么要使用堆内存：
1、随着程序的复杂数据只会越来越多
2、其它内存段的申请释放不受控制，堆内存的申请释放是受控制

如何使用堆内存：
注意：C语言中没有控制堆内存的语句，只能使用C标准库提供的函数
#include <stdlib.h>

void *malloc(size_t size);
功能：从堆内存中申请size个字节的内存，申请到的内存存储是什么内存不确定
返回值：成功返回申请到的内存的首地址，失败返回NULL

int main(int argc,const char* argv[])
{
	// 从堆内存中分配一块内存,首地址存放在指针变量中
	int* p1 = malloc(40);
	for(int i=0; i<10; i++)
	{
		p1[i] = i;
	}
	free(p1);
	p1 = NULL;
	
	//int* p = malloc(10*4);
	int* p = calloc(10,4);
	for(int i=0; i<10; i++)
	{
		//p[i] = i;
		printf("%d\n",p[i]);
	}

	//	解引用 使用堆内存
	*p = 100;

	//	释放堆内存
	free(p);
	for(int i=0; i<10; i++)
	{
		//p[i] = i;
		printf("%d\n",p[i]);
	}
	p = NULL;
}

int main(int argc,const char* argv[])
{
	int* p = malloc(4);

	for(int i=0; i<1024*33-2; i++)
	{
		p[i] = 10;	
	}
}

void free(void *ptr);
功能：释放一块堆内存，可以释放NULL，但是不能重复释放和释放非法地址
注意：释放仅仅只是回收使用权，里面数据是不会被特意清理

void *calloc(size_t nmemb, size_t size);
功能：从堆内存中申请nmemb块size 个字节的内存，申请到的内存块会被初始化为0
注意：申请到的依然是一块连续的内存

void *realloc(void *ptr, size_t size);
功能：改变已有内存块的大小，size表示调整后的大小
返回值：是调整后的内存块首地址，一定要重新接收该函数的返回值，可能不是在原基础上调整的
    如果无法在原基础上调整：
        1、申请一块size大小的内存
        2、把原内存上的内容拷贝过去
        3、把原内存释放，再返回新内存的首地址

int main(int argc,const char* argv[])
{
	int* p = malloc(40);
	for(int i=0; i<10; i++)
	{
		p[i] = i;	
	}
	int* p2 = malloc(20);
	int* p1 = realloc(p,80);
	p[50] = 100;//看不出来有问题，但是有隐患
	
	for(int i=0; i<10; i++)
	{
		printf("%d ",p1[i]);	
	}

printf("%p %p\n",p,p1);

}
malloc的内存管理机制：
当首次向malloc申请内存时，malloc会向操作系统申请内存，操作系统会直接给33页（1页=4096字节）内存交给malloc管理。
但是不意味着你可以越界访问该内存，因为malloc也会把内存分配给"其他人"，这样就会产生脏数据

每次申请的内存块之间是有一些空隙(4~12字节)，这些空隙是为了内存对齐，其中一定有4个字节记录着malloc维护信息，这些维护信息决定了下一次malloc时分配内存的位置，也可以借助这些信息计算出内存块的大小，如果这些维护信息被破坏会影响下一次malloc以及free

使用堆内存需要注意的问题：
内存泄漏：
内存无法使用，也无法释放，而再次使用时只能重新申请，然后重复以上过程，日积月累系统中可用的内存会越来越少
注意：程序一旦结束属于它的资源都会被操作系统回收
如何避免内存泄漏：
谁申请的谁释放，谁知道释放谁释放

    如何定位内存泄漏：（上网搜搜）
    1、查看内存使用情况 ps -aux
    2、分析代码，使用代码分析工具检查malloc的书写情况
    3、封装malloc、free，记录申请、释放的信息到日志

内存碎片：
    已经释放但无法继续使用的内存叫内存碎片，由于申请和释放的时间不协调导致的，内存碎片无法避免，只能尽量减少

    如何减少内存碎片：
        1、尽量使用栈内存
        2、不要频繁地申请释放内存
        3、尽量申请大块内存自己管理

内存清理函数：
#include <strings.h>
void bzero(void *s, size_t n);
功能：把一块内存清理为0
s：清理的内存块的首地址
n: 内存块的字节数

#include <string.h>
void *memset(void *s, int c, size_t n);
功能：把内存按字节设置为c
s:内存块首地址
c:想要设置的ASCII码值
n：内存的字节数
返回值：成功返回设置后的内存首地址

堆内存定义二维数组：
指针数组：
类型* arr[n];
int* arr[n] = {};
for(int i=0; i<n; i++)
{
arr[i] = malloc(sizeof(类型)*m); //容易产生内存碎片
}
注意：每一行的m可以不同，这就可以形成不规则的二维数组

数组指针：
    类型 (*arrp)[列数] = malloc(sizeof(类型)*行数*列数);
    //对内存要求高
    注意：所谓的多维数组都是用一维数组来模拟的
    练习1：计算出100~1000之间的所有素数，结果要存储在堆内存中，不能浪费内存
    1、先算有多少个，一下申请内存，再计算放入
    2、边算边扩充内存

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <stdbool.h>

bool is_prime(int num)
{
	for(int i=2; i<=sqrt(num); i++)
	{
		if(0 == num%i)	return false;	
	}
	return true;
}

int main(int argc,const char* argv[])
{
	int* arr = NULL,cnt = 0;
	for(int i=100; i<=1000; i++)
	{
		if(is_prime(i))
		{
			arr = realloc(arr,sizeof(int)*(cnt+1));	
			arr[cnt++] = i;
		}
	}

	for(int i=0; i<cnt; i++)
	{
		printf("%d ",arr[i]);	
	}
	free(arr);
	arr = NULL;
	return 0;
}