目录
目录
动态内存管理
到目前为止我们C语言学习的开辟内存的方式主要有两种：
1、创建变量（全局变量存储在静态域中，局部变量存储在栈中）
2、创建数组
这两种方式开辟的空间都是固定的，比如 int a 在内存中开辟4个字节；而 我们有时候需要开辟的空间是事先不知道的，这就要引入动态内存管理这个概念。
一、什么是动态内存管理？
如上面介绍的两种开辟内存空间的方式：
int val = 20;//在栈空间上开辟四个字节
char arr[10] = {0};//在栈空间上开辟10个字节的连续空间二、常见的动态内存分配函数
1.malloc函数
void* malloc(size_t size);函数说明：这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。
函数输入：size_t无符号整型；向内存申请size个字节空间；
函数输出：void* 指针；如果开辟成功，则返回一个指向开辟好空间的指针。如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
注意事项：返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。
代码1：
# include <stdio.h>
# include <stdlib.h>
# include <errno.h>
# include <string.h>
int main()
{
int i = 0;
//创建空间,开辟400个字节，指针类型强转为int*
int* p = (int*)malloc(100*sizeof(int));
printf("%p\n",p);
//判段是否开辟成功；开辟成功返回int*指针；开辟失败创建空指针
if(p == NULL)
{
//打印报错信息
printf("%s\n",strerror(errno));
}
else
{
//给开辟的空间赋值
for(i = 0; i < 100; i++)
{
*(p+i) = i;
}
}
//打印结果
for(i = 0; i<100; i++)
{
printf("%d ",*(p+i));
}
//回收空间
free(p);
//把指针赋值为空指针
p = NULL;
return 0;
}代码1结果演示：
01583030
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 请按任意键继续. . .2.free函数
void free(void* ptr);函数说明：free函数用来释放动态开辟的内存。
函数输入；void* 类型指针；ptr是指向动态内存的指针；
注意事项：如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。 如果参数 ptr 是NULL指针，则函数什么事都不做。动态内存开辟的空间本身拥有自己的生命周期，过了生命周期就会自动回收不一定需要free函数。比如代码1，不加free函数会在return后回收动态空间。free相当于主动回收。
代码演示：
如代码1
3.calloc函数
void* calloc(size_t num, size_t size);函数说明：函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
函数输入：函数说明里面很详细了；
函数输出：与malloc输出一样；
注意事项：与malloc一样；
代码2演示
# include <stdio.h>
# include <stdlib.h>
# include <errno.h>
# include <string.h>
int main()
{
int i = 0;
//创建空间,开辟400个字节，指针类型强转为int*,并初始化为0；
int* p = (int*)calloc(10,sizeof(int));
printf("%p\n",p);
//判段是否开辟成功；开辟成功返回int*指针；开辟失败创建空指针
if(p == NULL)
{
//打印报错信息
printf("%s\n",strerror(errno));
}
else
{
//打印初始化好的动态空间
for(i = 0; i < 10; i++)
{
printf("%d ",*(p+i));
}
printf("\n");
}
//释放空间
free(p);
//p赋值为空指针
p = NULL;
return 0;
}代码2结果：
013D3030
0 0 0 0 0 0 0 0 0 0
请按任意键继续. . .4.calloc函数
void* realloc(void* ptr, size_t size);函数说明：在原来动态内存ptr变为size个字节的动态内存空间。
函数输入：ptr 是要调整的动态内存地址，size 调整之后新大小；
函数输出：返回值为调整之后的内存起始位置。（最好重新定义变量）；
注意事项：数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。realloc在调整内存空间的是存在两种情况： 情况1：原有空间之后有足够大的空间，当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。情况2：当是情况2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小 的连续空间来使用。这样函数返回的是一个新的内存地址。
代码3演示：
# include <stdio.h>
# include <stdlib.h>
# include <errno.h>
# include <string.h>
int main()
{
int i = 0;
int* ptr;
//创建空间,开辟40个字节，指针类型强转为int*,并初始化为0；
int* p = (int*)calloc(10,sizeof(int));
printf("%p\n",p);
//判段是否开辟成功；开辟成功返回int*指针；开辟失败创建空指针
if(p == NULL)
{
//打印报错信息
printf("%s\n",strerror(errno));
}
else
{
//打印初始化好的动态空间
for(i = 0; i < 10; i++)
{
printf("%d ",*(p+i));
}
printf("\n");
}
//追加空间；情况1，p后面剩余空间充足；空间由40字节
//变成44个字节
ptr = (int*)realloc(p,11*sizeof(int));
//打印返回后地址
printf("p:%p\nprt:%p\n",p,ptr);
if(ptr != NULL)
{
//打印追加后空间内容
for(i = 0; i < 11; i++)
{
printf("%d ",*(ptr+i));
}
printf("\n");
}
//追加空间；情况2，p后面剩余空间充足；空间由40字节
//变成80个字节
ptr = (int*)realloc(p,20*sizeof(int));
//打印返回后地址
printf("p:%p\nprt:%p\n",p,ptr);
//释放空间
free(ptr);
//p,ptr赋值为空指针
p = NULL;
ptr = NULL;
return 0;
}代码3结果演示：
01203030
0 0 0 0 0 0 0 0 0 0
p:01203030
prt:01203030
0 0 0 0 0 0 0 0 0 0 -842150451
p:01203030
prt:012040B8
请按任意键继续. .三、常见错误
1.对NULL指针的解引用操作
int main()
{
int* p = (int*)malloc(10*sizeof(int));
*p = 20; // 如果p是NULL指针，就会有问题；
free(p);
return 0;
}上面代码主要问题是，对malloc返回的指针类型没有检查。
2.对动态内存开辟的空间越界访问
int main()
{
int i;
int* p = (int*)malloc(10*sizeof(int));
if(p==NULL)
{
printf("%s\n",strerror(errno));
}
else
{
for(i=0; i<=10;i++)
{
*(p+i)=i; //当i=10时会造成越界访问
}
}
free(p);
return 0;
}3.对非动态开辟的内存空间使用free释放
int main()
{
int a = 10;
int* p = &a;
free(p);
return 0;
}由于a是创建在栈区的变量，free只能释放堆区的动态内存，所以会报错。
4.使用free释放一块动态开辟内存的一部分
int main()
{
int* p = (int*)malloc(10*sizeof(int));
p++;
free(p); //此时p不再指向动态内存的初始位置
return 0;
}5.对同一块动态开辟内存重复释放
int main()
{
int* p = (int*)malloc(10*sizeof(int));
free(p);
//p = NULL; //加上这一行不用担心重复释放
free(p); //此时p不再指向动态内存的初始位置
return 0;
}释放完内存之后最好把指针赋值为空指针，这样不用担心重复释放，因为free函数接收空指针后不会进行释放操作。
6.动态开辟内存忘记释放（内存泄漏）
int main()
{
while(1)
{
int* p = (int*)malloc(10*sizeof(int));
}
return 0;
}内存一直开辟不释放，内存就会一直被消耗，直到内存被耗干，程序挂掉。所以动态内存一定要记得正确释放。
四、柔性数组
也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。 C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。比如：
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;typedef struct st_type
{
int i;
int a[];//柔性数组成员
}type_a;1.柔性数组特点
结构中的柔性数组成员前面必须至少一个其他成员。
sizeof 返回的这种结构大小不包括柔性数组的内存。
2.柔性数组的使用
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
//创建柔性数组1
struct S
{
int n;
int arr[0];
};
int main()
{
int i;
int n; //控制数组大小n
//输出结构体占用内存大小
//printf("%d\n",sizeof(struct S)); // 4 ;并没有计算arr[]大小
//创建柔性数组,使用malloc开辟了4+10*4=44个字节空间
struct S* ps = (struct S* )malloc(sizeof(struct S)+n*sizeof(int));
ps->n = 100;
for(i=0;i<n;i++)
{
ps->arr[i] = i;
}
//打印数组
for(i=0;i<10;i++)
{
printf("%d ",ps->arr[i]);
}
free(ps);
ps=NULL;
return 0;
}代码1结果演示
0 1 2 3 4 5 6 7 8 9 请按任意键继续. . .柔性数组创建方式二：
代码2演示
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
//创建柔性数组2
typedef struct s
{
int n;
//创建数组的指针
int* arr;
}type_s;
int main()
{
int num = 10;//控制
int i;
//首先给结构体开辟空间
type_s* ps = (type_s*)malloc(sizeof(type_s));
//然后给数组开辟空间
ps->n = 100;
ps->arr = (int*)malloc(num*sizeof(int));
//给数组赋值
for(i=0;i<num;i++)
{
ps->arr[i] = i;
}
//打印数组
for(i=0;i<num;i++)
{
printf("%d ",ps->arr[i]);
}
free(ps->arr);
ps->arr = NULL;
free(ps);
ps = NULL
}代码2结果演示
0 1 2 3 4 5 6 7 8 9 请按任意键继续. . .3.柔性数组优势
- 方便内存释放；如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
-
这样有利于访问速度 ； 连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正 你跑不了要用做偏移量的加法来寻址）
2547
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
