动态内存管理

考虑到数组不能定死，因此需要动态开辟空间。

为什么存在动态内存分配

int val=20;
char arr[10]={0};

• 空间开辟大小是固定的
• 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配

栈区：局部变量，函数形参

堆区：malloc，calloc，free，realloc

静态区（数据段）：全局变量，静态变量

动态内存函数的介绍

1.malloc和free

void* malloc(size_t size);

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

• 如果开辟成功，则返回一个指向开辟好空间的指针。
• 如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
• 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自 己来决定。
• 如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

int main()
{
    //假设开辟10个整型的空间 --10*sizeof(int)
	int* p=(int*)malloc(10*sizeof(int));    
    if(p==NULL)
    {
        perror("main");///main:xxxx
        return 0;
    }
    //使用
    int i=0;
    for(int i=0;i<10;i++)
    {
      	*(p+i)=i;
    }
    for(int i=0;i<10;i++)
    {
        printf("%d\n",p[i]);
    }
    
    free(p);///回收空间,p指针不会被默认为空指针。
    p=NULL;//重要！！自己动手把指针置为NULL
    return 0;
}

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

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

  • int main()
    {
        int a=10;
        int *p=&a;
        free(p);//!!
    }
    

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

2.calloc

开辟一块空间并且初始化为0.

void* calloc(size_t num,size_t size)
{   
}
//num---需要元素的个数
//一个元素的大小

3.realloc

• realloc的出现让动态内存管理更加灵活
• 有时我们会发现过去申请的空间太小了，有时候我们又觉得申请的空间过大了，那为了合理的适合内存，我们一定会对内存大小做灵活的调整
• realloc在调整空间时
  • 弥补后两块合起来在当前堆空间里没有其他碰撞
    • 连接上去，指针指向的地址不变。
  • 在第二块拼接到前面的时候和堆空间里其他内存块碰撞了
    • 重新找一块空间，把原先空间的内
    • 容拷贝下来，再返回新地址。
    • 原来的那一块空间还给操作系统。
  • 找不到合适的空间调整大小
    • 返回空指针
  • 因此realloc后不要把原来的p指针被赋值修改。
• 单独使用realloc的时候也能实现malloc的效果

void* realloc(void* memblocks,size_t size);
memblock---前面开辟的内存空间起始地址
size--新的大小

int main()
{
    int* p=(int*)malloc(10*sizeof(int));
    if(p==NULL)
    {
        perror("main");
        return 1;
    }
    int i=0;
    for(int i=0;i<10;i++)
    {
		*(p+i)=5;
    }
    //还需要5个,这里需要p指向的空间更大,需要20个int空间
    //realloc 调整空间
    realloc(p,20*sizeof(int));///新的大小
    ///返回重新调整后的内存块指针
    //p=realloc(p,20*sizeof(int));///!!! 可能偷鸡不成蚀把米
    //拿临时指针
    int* ptr=realloc(p,20*sizeof(int));
    if(ptr!=NULL) p=ptr;
    free(p);
    p=NULL;
    return 0;
}

int main()
{
	int* p=(int*)realloc(NULL,40);//这里功能类似malloc
}

常见的动态内存错误

1.对NULL指针的解引用操作

• 对malloc函数的返回值做判空处理

int main()
{
	int *p=(int*)malloc(1000000000*sizeof(int));
	//if(p==NULL)
    for(int i=0;i<10;i++)
    {
        *(p+i)=i;///非法访问内存
    }
    return 0;
}

2.对动态开辟的空间进行越界内存访问

int main()
{
    int* p=(int*)malloc(10*sizeof(int));
    if(p==NULL)
    {
        return 1;
    }
    int i=0;
    for(i=0;i<40;i++)
    {
        *(p+i)=i;
    }
    free(p);
    return 0;
}

3.对非动态开辟空间使用free

int main()
{
    int arr[10]={0};
	int* p=arr;
    //使用
    free(p);//对非动态开辟空间使用free
    p=NULL;
}

4.用free释放动态开辟内存的一部分

• 内存泄漏

int main()
{
    int *p=malloc(10*sizeof(int));
    if(p!=NULL) return 1;
    for(int i=0;i<5;i++)
    {
        *p++=i;
    }
    free(p);
    p=NULL;
}

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

• 所以防止这种情况一旦释放完养成置为NULL指针就不会产生这种问题

int main()
{
    int* p=(int*)malloc(100);
    //使用
    //释放
    free(p);
    //释放
    free(p);
    return 0;
}

6.动态开辟的空间忘记释放

void test
{
    int* p=(int*)malloc(100);
    if(p==NULL)
    {
        return;
    }
    //使用
    
}
int main()
{
    test();
    
    //...
    return 0;
}

练习题

void GetMemory(char *p)
{
 	p = (char *)malloc(100);
}
//改:
char* GetMemory(char  *p)
{
    p = (char *)malloc(100);
    return p;
}
//改:
void GetMemory(char** p)
{
    *p = (char *)malloc(100);
}
GetMemory(&str);
void Test(void)
{
 	char *str = NULL;
 	str=GetMemory(str);
 	strcpy(str, "hello world");
 	printf(str);//?ok
    printf("hello world");//本质是传过去h的地址
	free(str);
}

• 值传递

• p指针malloc后指向申请的空间

• 但是str仍然是NULL

• 归类维为：返回栈空间地址的问题

  • 上题是堆

char *GetMemory(void)
{
 	char p[] = "hello world";
 	return p;//char* tmp=p; return tmp;
}
void Test(void)
{
 	char *str = NULL;
 	str = GetMemory(); ///这里就要开始认为，结束栈帧后里面的东西就给“销毁了”。出现这种情况一律认为不行
 	printf(str);
}
int main()
{
	Test();
}

• 野指针问题

  • 指针声明的时候要初始化

• 没有free

void GetMemory(char **p, int num)
{
 	*p = (char *)malloc(num);
}
void Test(void)
{
 	char *str = NULL;
 	GetMemory(&str, 100);
 	strcpy(str, "hello");
 	printf(str);
    free(str);
}

void Test(void)
{
 	char *str = (char *) malloc(100);
 	strcpy(str, "hello");
 	free(str);
 	if(str != NULL)
 	{
 		strcpy(str, "world");
 		printf(str);
 	}
}
///提前free.

总的来说

• 栈空间和堆空间的内存开辟
• 野指针问题
• free问题
  • malloc必定要有free
  • free后必定要置空

c++中程序内存空间分布

• 内核空间（栈区）
  • 用户代码不能读写
• 栈 （栈区）
  • 向下增长
• 内存映射段（堆区）
  • 文件映射
  • 动态库
  • 匿名映射
• 堆（堆区）
  • 向上增长
• 数据段（静态区）
  • 全局数据
  • 静态数据
• 代码段（静态区）
  • 可执行代码
  • const常量

对开始讲到的static修饰局部变量：

实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就

销毁。

但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁。

所以生命周期变长。

柔性数组

C99中，结构中的最后一个元素允许是未知大小的数组，这个称为[柔性数组]成员。

struct S
{
    int n;
    int arr[];//大小是未知的
};
struct S
{
    int n;
    int arr[0];//柔性数组成员
};
//两者都可以
int main()
{
    struct S s={0};//这样创建arr是没法使用的
    printf("%s\n",sizeof(s));///4
    //期望arr的大小是10个int
    struct S* ps=(struct S*)malloc(sizeof(struct S)+10*sizeof(int));
	//增加
    struct S* ptr=(struct S*)realloc(ps,sizeof(struct S)+20*sizeof(int));
    if(ptr!=NULL)
    {
        ps=ptr;
    }  
    free(ps);
    ps=NULL;
    return 0;
}

• 结构中的柔性数组成员前面必须至少包含一个其他成员
• sizeof返回的这种结构的大小不包含柔性数组
• 包含柔性数组成员的结构用malloc()进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
• 尝试代替柔性数组
  • malloc两次
  • 频繁malloc内存碎片增加
  • 内存池！！
  • 柔性数组连续，空间局部性更高

struct S{
    int n;
    int* arr;
};
int main()
{
    struct S* ps=(struct S*)malloc(sizeof(struct S));
    if(ps==NULL) return 1;
    ps->n=10;
    ps->arr=(int*)malloc(10*sizeof(int));
    if(ps->arr==NULL)
    {
        return 1;
    }
    int i=0;
    for(i=0;i<10;i++) ps->arr[i]=i;
    //增加
    int* ptr=realloc(psr->arr,20*sizeof(int));
    if(ptr!=NULL)
    {
        ps->arr=ptr;
    }
    //使用
    
    //释放
    free(ps->arr);
    ps->arr=NULL;
    free(ps);
    ps=NULL;
}

柔性数组优势

• 方便内存释放
• 有利于提高访问速度