动态内存管理

动态内存管理

动态内存函数

在堆区申请的空间，动态开辟的空间不要忘了释放

malloc

参数是无符号的整型，表示的是多少字节数。当参数为0时，这是标准没有定义的。取决于编译器。
返回类型为

void*

的指针。
当空间开辟成功的时候，返回指向该空间的地址。
当空间开辟失败的时候，返回空指针。

malloc

开辟是一个连续的空间。开辟完成之后都要判断一下有没有成功

例：

#include<stdio.h>#include<stdlib.h>#include<string.h>intmain(){char* p =(char*)malloc(10*sizeof(char));if(p ==NULL){printf("%s",strerror(errno));return0;}char* arr = p;int i =0;for(i =0; i <10; i++){*arr++= i;}free(p);
    p =NULL;return0;}

calloc

开辟动态内存空间的同时初始化空间为0，每个字节都初始化为0。

num

是元素的个数，

size

每个元素的大小。
开辟空间成功返回指向该空间的指针
开辟空间失败返回空指针

NULL

。

例：

#include<stdio.h>#include<stdlib.h>#include<string.h>intmain(){int* p =(int*)calloc(5,sizeof(int));;if(p ==NULL){printf("%s\n",strerror(errno));return0;}int i =0;for(i =0; i <5; i++){*(p + i)= i;}free(p);
    p =NULL;return0;}

realloc

重新分配动态内存的函数.。
第一个参数为指向动态开辟空间的指针，第二个参数为从新开辟内存的大小，单位字节。
当第一个参数为空指针

NULL

时。和

malloc

一样。
开辟成功返回，返回从新开辟空间的地址。
开辟失败返回空指针。

有两种情况：
1. 以前动态开辟的空间后面的空间够再次开辟，那么

realloc

直接在以前开辟的后面进行开辟。

2. 以前动态开辟的空间后面的空间不够再次开辟，会重新找一块空间进行开辟，同时把以前的数据拷贝新开辟的里面。以前动态开辟的空间被销毁。

例：

#include<stdio.h>#include<stdlib.h>#include<string.h>intmain(){char* p =(char*)malloc(10*sizeof(char));if(p ==NULL){printf("%s\n",strerror(errno));return0;}char* str =(char*)realloc(p,20*sizeof(char));if(str ==NULL){printf("%s\n",strerror(errno));return0;}
    p = str;free(p);
    p =NULL;return0;}

free

释放动态开辟的内存空间。参数是指向动态内存的指针，是首地址。
当参数为

NULL

的时候，什么都不发生。

常见的动态内存错误

对NULL指针的解引用操作

这里的

p

万一是空指针，下面这种就是错误

char* p =(char*)malloc(10*sizeof(char));*p =1;

正确的做法是开辟完成之后，需要判断是不是空指针。

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

其实和数组一样，动态内存开辟的空间也有边界，也是不能越界的。

char* p =(char*)malloc(10*sizeof(char));if(p ==NULL){printf("%s\n",strerror(errno));return0;}int i =0;for(i =0; i <=10; i++)//当i=10的时候就越界了{*(p + i)= i;}

释放非动态内存开辟的空间

int a =10;int* p =&a;free(p);
p =NULL;

使用free释放一块动态开辟内存的一部分

free

一定要释放指向动态内存开辟的那个首地址。

char* p =(char*)malloc(10*sizeof(char));if(p ==NULL){printf("%s\n",strerror(errno));return0;}int i =0;for(i =0; i <5; i++){*p++= i;}//这里释放一部分，这是错误的。free(p);

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

char* p =(char*)malloc(10*sizeof(char));if(p ==NULL){printf("%s\n",strerror(errno));return0;}free(p);free(p);

解决方法为：释放空间之后就制成空指针。

动态开辟内存忘记释放（内存泄漏）

一定一定不要忘了释放

char*f(){char* p =(char*)malloc(10);return p;}intmain(){char* ret =f();return0;}

柔性数组

结构体中允许最后一个成员为未知大小的数组，该数组就是柔性数组成员。

例：

structs{int i;int arr[];
    下面的这种也是可以的
    int arr[0];};

柔性数组的特点

1.结构体至少包括一个非柔性数组成员
2.

sizeof

求这种类型的时候，不包括柔性数组。
3.动态开辟的时候，其开辟的大小要大于这种类型的大小。以满足可以给柔性数组进行开辟空间。

使用：

structs{int i;int arr[];//int arr[0];};intmain(){structs* p =(structs*)malloc(sizeof(structs)+20);if(p ==NULL){return0;}
    p->i =6;int n;for(n =0; n <5; n++){
        p->arr[n]= n;}free(p);
    p =NULL;return0;}

像上面那样，我们还可以用其他的方式进行实现：
如

structs{int i;int* arr;};intmain(){structs* p =(structs*)malloc(sizeof(structs));if(p ==NULL){return0;}
    p->i =6;
    p->arr =(int*)malloc(5*sizeof(int));free(p->arr);
    p->arr =NULL;free(p);
    p =NULL;return0;}

虽然这样也可以实现，但是两次开辟的空间不是连续。要注意释放的顺序，否则会造成内存泄漏。
使用柔性数组不会出现这种情况。