C语言动态内存管理
1.存在动态内存分配的原因
已有的开辟内存的方式
int a=10;//在栈区开辟4个字节的空间
char arr[5]={0};//在栈空间开辟5个字节的空间
但上述开辟的内存空间有局限性：
1.开辟的空间大小是固定的
2.数组在声明的时候，必须指定数组的长度，它所需要的内存在编译时分配
但是我们有时需要根据实际情况来实时开辟内存，有些需要程序运行时才知道，所以需要动态内存管理。
内存分为栈区、堆区、静态区
2. malloc函数
2.1malloc函数介绍
两个函数的声明都在stdlib.h的头文件中
void *malloc( size_t size );
参数：无符号整数（size_t)类型的size，代表内存块的大小，单位是字节，比如size=40，就代表像内存开辟40个byte的空间
返回值：若成功开辟内存空间，返回指向函数分配的内存块的指针，若开辟失败，则返回一个空指针NULL，故需要对返回值进行检查
注意：1.由于malloc的返回值是void*，并没有指明具体的类型，所以使用者应该根据实际情况进行强制类型转换
2.新分配的内存块的内容未初始化
2.2malloc函数使用
#include<stdio.h>
#include <stdlib.h>
int main()
{
//动态内存开辟
int* p = (int*)malloc(10 * sizeof(int));//开辟40个字节的空间
if (p == NULL)
{
perror("main");
return 0;
}
int i = 0;
for (i = 0; i < 10; i++)//对开辟的内存空间赋初值
{
*(p + i) = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", p[i]);
}
free(p);
p = NULL;
return 0;
}
输出结果：
1.使用malloc函数需要的头文件是 #include <stdlib.h>
2.由于开辟的10个int的空间，所以需要使用int* 指针进行接收，方便以后解引用一次访问一个整型，并且强制类型转换成int*
3.malloc有可能开辟失败，所以需要对它的返回值进行判断
4.最后需要对开辟的内存进行释放
2.free函数
2.1free函数介绍
c语言提供了另一个函数free来对动态内存空间进行释放和回收的，总是与malloc成对出现
void free( void* memblock );
参数：指向先前使用或分配的内存块的指针
返回值：空
注意：1.该函数是解除已经分配的内存块的空间，如果不是上述分配的内存块的空间，会出现一些未定义的行为
2.如果参数是空指针，则不进行任何操作
2.2free函数的使用
free(p);
p = NULL;
1.该函数不是这样简单的使用，通常与malloc、calloc、realloc成对出现
2.该函数需要的头文件是 #include <stdlib.h>
根据2.2中的代码
经过free( p ) 后空间被释放，然后p指向空指针
3.calloc函数
3.1calloc函数介绍
void *calloc( size_t num, size_t size );
参数：无符号整数（size_t)类型的num，代表要分配的元素的数目，size代表每个元素的大小单位是字节，比如要开辟40个byte，则num=10,size=4
返回值：若成功开辟内存空间，返回指向函数分配的内存块的指针，若开辟失败，则返回一个空指针NULL，故需要对返回值进行检查
注意：1.由于calloc的返回值是void*，并没有指明具体的类型，所以使用者应该根据实际情况进行强制类型转换
2.新分配的内存块的内容默认初始化为0
3.2calloc函数的使用
#include<stdio.h>
#include <stdlib.h>
int main()
{
int* p = (int*)calloc(5, sizeof(int));
if (p == NULL)
{
perror("main");
}
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%d ", *(p + i));//0 0 0 0 0
}
free(p);
p = NULL;
return 0;
}
输出结果：
4 realloc函数
4.1realloc函数介绍
realloc函数使得动态内存管理更加灵活，可以做到对动态开辟内存的大小的调整,为了合理的使用内存，我们一定会对内存的大小做灵活的调整，那么realloc 函数就可以做到对动态开辟内存大小的调整。
void *realloc( void* memblock, size_t size );
参数：memblock是要修改的内存空间的地址，size是内存块的新的大小，单位是字节
返回值：指向重新分配的内存块的指针，若空间够则要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。若不够，则在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址
注意：1.由于realloc的返回值是void*，并没有指明具体的类型，所以使用者应该根据实际情况进行强制类型转换
3.realloc() 对 ptr 指向的内存重新分配 size 大小的空间，size 可比原来的大或者小，还可以不变
4.2realloc函数的使用
#include<stdio.h>
#include <stdlib.h>
int main()
{
int* p = (int*)calloc(5, sizeof(int));
if (p == NULL)
{
perror("main");
}
int i = 0;
for (i = 0; i < 5; i++)
{
*(p + i) = i;
}
//扩容5个int
int* ptr = (int*)realloc(p, 20+5 * sizeof(int));//共40个字节，10个int
if (ptr != NULL)
{
p = ptr;
}
free(p);
p = NULL;
return 0;
}
realloc有可能找不到合适的空间来扩容，这时就返回NULL,因此需要一个临时变量来接收，防止p找不到原来的位置
5 C/C++程序的内存开辟
1.栈区（stack)：函数内的局部变量的存储单元都可以在栈区上创建，函数结束时这些存储单元自动释放。栈区分配运算内置于处理器的指令集中，效率高，但是分配的内容有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等
2.堆区（heap）：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收，分配方式类似于链表
3.数据段（静态区）：static存放全局变量、静态数据，程序结束后由系统释放
4.代码段：存放函数体（类成员函数和全局函数）的二进制代码
6 柔性数组
C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做柔性数组成员
typedef struct st_type
{
int i;
int a[0];//柔性数组成员，有些编译器报错可改成int a[];
}type_a;
6.1柔性数组的特点
#include <stdio.h>
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;
int main()
{
printf("%d\n", sizeof(type_a));
return 0;
}
输出结果：
1.结构中的柔性数组成员前面必须至少一个其他成员
2.sizeof 返回的这种结构大小不包括柔性数组的内存
3.包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小
6.2柔性数组的使用
#include <stdio.h>
#include <stdlib.h>
struct S
{
int i;
int arr[];
};
int main()
{ //开辟
struct S* ptr1 = (struct S*)malloc(sizeof(struct S) + 40);//4+40个字节
if (ptr1 == NULL)
{
perror("ptr1");
return 1;
}
//使用
ptr1->i = 10;
int i = 0;
for (i = 0; i < 10; i++)
{
ptr1->arr[i] = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", ptr1->arr[i]);
}
printf("\n");
//扩容
struct S* ptr2 = (struct S*)realloc(ptr1,sizeof(struct S) + 80);//4+40+40个字节
if (ptr2 != NULL)
{
ptr1 = ptr2;
}
//再使用
ptr1->i = 10;
for (i = 0; i < 20; i++)
{
ptr1->arr[i] = i;
}
for (i = 0; i < 20; i++)
{
printf("%d ", ptr1->arr[i]);
}
//释放
free(ptr1);
ptr1 = NULL;
return 0;
}
输出结果：
1.ptr2不需要释放，它和ptr1指向的地址一样，如果先把ptr2释放了，ptr1就成了野指针，只需释放ptr1即可
6.3柔性数组的优势
#include <stdio.h>
#include <stdlib.h>
struct S
{
int n;
int* arr;
};
int main()
{
//开辟
struct S* ps = (struct S*)malloc(sizeof(struct S));
if (ps == NULL)
{
return 1;
}
ps->n = 100;
ps->arr = (int*)malloc(40);
if (ps->arr == NULL)
{
perror("ps->arr");
return 1;
}
//使用
int i = 0;
for (i = 0; i < 10; i++)
{
ps->arr[i] = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", ps->arr[i]);
}
//扩容
int*ptr = (int*)realloc(ps->arr, 80);
if (ptr == NULL)
{
perror("ptr");
return 1;
}
//使用
//……
//释放
free(ps->arr);
free(ps);
ps = NULL;
return 0;
}
1.与6.2相比，此代码malloc两次，分别是结构体和arr*，也对应着free了两次，更容易出现内存泄露，内存碎片更多
2.为了控制变量，都在堆上开辟
优势1：方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
优势2：这样有利于访问速度.
连续的内存有益于提高访问速度，也有益于减少内存碎片。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
