目录
前言
当一个内存空间是程序运行前我们无法确定的，且大小无法估计，这就是动态内存。今天我们来讲一下C语言中动态内存管理，
一、动态内存分配
为什么要动态内存分配呢？让我们来看一下我们已知的开辟内存空间的方法：
int val = 20;//在栈空间上开辟四个字节
char arr[10] = {0};//在栈空间上开辟10个字节的连续空间
但是上述的开辟空间的方式有两个特点：
•
空间开辟大小是
固定
的。
•
数组在申明的时候，必须
指定数组的⻓度
，数组空间⼀旦确定了大小不能调整
但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知
道，那数组的编译时开辟空间的方式就不能满⾜了。
C语⾔引⼊了
动态内存开辟
，让程序员自己可以
申请和释放
空间，就比较灵活了。
二、malloc和free函数
2.1 malloc函数
C语言中malloc函数就是来开辟内存空间的：
void* malloc (size_t size);
这个函数向内存申请⼀块
连续可用
的空间，并返回指向这块空间的
指针
。
•
需要头文件
#include<stdlib.h>
•
如果开辟成功，则返回⼀个指向开辟好空间的指针。
•
如果开辟失败，则返回⼀个
NULL
指针，因此malloc的返回值⼀定要做
检查
。
•
返回值的类型是
void*
，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使⽤者⾃
自己来决定。
•
如果参数
size
为0，malloc的行为是标准是未定义的，取决于编译器。
#include<stdio.h>
#include<stdlib.h>
int main() {
int* p = (int*)malloc(5 * sizeof(int));//开辟5个整型的空间
if (p == NULL) { //判断返回是否为空
return 1;
}
}
如图开辟了五个整型的空间，值为随机值。
2.2 free函数
free
函数
，专门是⽤来做动态内存的释放和回收的，函数原型如下：
void free (void* ptr);
free
函数用来
释放
动态开辟的内存。
•
需要头文件
#include<stdlib.h>
•
如果参数
ptr
指向的空间不是动态开辟的，那free函数的行为是未定义的。
•
如果参数
ptr
是
NULL
指针，则函数什么事都不做。
#include<stdio.h>
#include<stdlib.h>
int main() {
int* p = (int*)malloc(5 * sizeof(int));//开辟5个整型的空间
if (p == NULL) { //判断返回是否为空
return 1;
}
int i = 0;
for (i = 0; i < 5; i++) {//赋值
*(p + i) = i;
}
for (i = 0; i < 5; i++) {
printf("%d ", *(p + i));
}
free(p);//释放动态内存空间
p = NULL;
}
free释放空间之前：
free释放空间之后：
最后p=NULL，是为了防止p变成野指针。
三、calloc和realloc函数
3.1 calloc函数
C语⾔还提供了⼀个函数叫
calloc
，
calloc
函数也⽤来动态内存分配。原型如下：
void* calloc (size_t num, size_t size);
•
需要头文件
#include<stdlib.h>
•
函数的功能是为
num
个大小为
size
的元素开辟⼀块空间，并且把空间的每个字节初始化为0。
•
与函数
malloc
的区别只在于
calloc
会在返回地址之前把申请的空间的每个字节初始化为全
0
#include<stdio.h>
#include<stdlib.h>
int main()
{
int* p = (int*)calloc(5, sizeof(int));//开辟5个大小为4的整型字节
if (NULL != p)
{
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%d ", *(p + i));//打印
}
}
free(p);
p = NULL;
return 0;
}空间的每个字节初始化为0：
所以如果我们对申请的内存空间的内容要求初始化，那么可以很方便的使用calloc函数来完成任务。
3.2 realloc函数
当我们有时感觉我们开辟的空间大了或者小了，我们难道需要重新开辟吗？
这个时候我们就可以使用realloc函数可以做到对动态开辟内存大小的调整，让动态内存管理更加灵活。函数原型如下：
void* realloc (void* ptr, size_t size);
•
ptr
是要调整的
内存地址
•
size
调整之后
新大小
•
返回值为调整之后的内存
起始位置
。
•
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
•
realloc在调整内存空间的是存在两种情况：
◦
情况1：原有空间之后
有足够大
的空间
要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。
◦
情况2：原有空间之后
没有足够大
的空间
扩展的方法是：在堆空间上另找⼀个合适大小的连续空间来使用。这样函数返回的是⼀个新的内存地址，具体步骤：
#include<stdio.h>
#include<stdlib.h>
int main()
{
int* ptr = (int*)malloc(100);
if (ptr != NULL)
{
//业务处理
}
else
{
return 1;
}
//扩展容量
//代码1 - 直接将realloc的返回值放到ptr中
ptr = (int*)realloc(ptr, 1000);
//代码2 - 先将realloc函数的返回值放在p中，不为NULL，在放ptr中
int* p = NULL;
p = realloc(ptr, 1000);
if (p != NULL)
{
ptr = p;
}
//业务处理
free(ptr);
return 0;
}代码1其实有问题，如果扩展失败，ptr就变为空指针了，会导致内存泄漏的问题。
上述讲的四个动态内存有关的函数都存放在内存的堆区：
四、常见的动态内存的错误
在了解动态内存后，我们现在来看一下常见的动态内存的错误。
1.对NULL指针的解引用操作
void test()
{
int *p = (int *)malloc(INT_MAX/4);
*p = 20;//如果p的值是NULL，就会有问题
free(p);
}2.对动态开辟空间的越界访问
void test()
{
int i = 0;
int *p = (int *)malloc(10*sizeof(int));
if(NULL == p)
{
exit(EXIT_FAILURE);
}
for(i=0; i<=10; i++)
{
*(p+i) = i;//当i是10的时候越界访问
}
free(p);
}3.对非动态开辟内存使用free释放
void test() {
int a = 10;
int *p = &a;
free(p);//error
}free只能释放堆区上的内存，及malloc/calloc/realloc函数开辟的内存空间。
4.使用free释放⼀块动态开辟内存的⼀部分
void test()
{
int *p = (int *)malloc(100);
p++;
free(p);//p不再指向动态内存的起始位置
}5.对同⼀块动态内存多次释放
void test()
{
int *p = (int *)malloc(100);
free(p);
free(p);//重复释放
}6.动态开辟内存忘记释放（内存泄漏）
void test()
{
int *p = (int *)malloc(100);
if(NULL != p)
{
*p = 20;
}
}
int main()
{
test();
while(1);
}调用完test函数后，指针变量*p被销毁了，但是开辟的内存空间还在，没有被释放。忘记释放不再使⽤的动态开辟的空间会造成内存泄漏。
切记：动态开辟的空间⼀定要释放，并且正确释放。
关于free函数
五、动态内存经典笔试题分析
5.1 题目1
void GetMemory(char *p)
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}
运行Test 函数会有什么样的结果？
GetMemory函数是传值，传递的是str的值，调用完会p会被销毁，会导致内存泄漏，而str还是空指针，对空指针解引用会导致程序崩溃。
5.2 题目2
char *GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char *str = NULL;
str = GetMemory();
printf(str);
}运行Test 函数会有什么样的结果？
GetMemory调用完后p数组空间会被销毁，返回的p就变成了一个野指针，结果不确定。
5.3 题目3
void GetMemory(char **p, int num)
{
*p = (char *)malloc(num);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}运行Test 函数会有什么样的结果？
GetMemory调用是传址调用，所以是str就为开辟空间的地址，就可以顺利打印了。
5.4 题目4
void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, "hello");
free(str);
if(str != NULL)
{
strcpy(str, "world");
printf(str);
}
}运行Test 函数会有什么样的结果？
开辟的空间提前被释放了，所以str指向的空间不存在了。
六、柔性数组
也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。
C99 中，结构中的
最后⼀个元素
允许是
未知
大小的数组，这就叫做『
柔性数组
』成员。
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;在有些编译器上报错，还可以改成：
typedef struct st_type
{
int i;
int a[];//柔性数组成员
}type_a;6.1 柔性数组的特点
•
结构中的柔性数组成员前面必须
至少⼀个其他成员
。
•
sizeof 返回的这种结构
大小不包括柔性数组的内存
。
•
包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该
大于
结构的 大小，以适应柔性数组的预期大小。
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;
int main()
{
printf("%d\n", sizeof(type_a));//输出的是4
return 0;
}输出结果为4，说明在计算大小不包括柔性数组的内存。
6.2 柔性数组的使用
//代码1
#include <stdio.h>
#include <stdlib.h>
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;
int main()
{
int i = 0;
type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));
//业务处理
p->i = 100;
for(i=0; i<100; i++)
{
p->a[i] = i;
}
free(p);
return 0;
}
这样柔性数组成员a，相当于获得了100个整型元素的连续空间。
6.3 柔性数组的优势
我们来看看下面柔性数组的优点，上面代码我们可以这样实现：
//代码2
#include <stdio.h>
#include <stdlib.h>
typedef struct st_type
{
int i;
int *p_a;
}type_a;
int main()
{
type_a *p = (type_a *)malloc(sizeof(type_a));
p->i = 100;
p->p_a = (int *)malloc(p->i*sizeof(int));
//业务处理
for(i=0; i<100; i++)
{
p->p_a[i] = i;
}
//释放空间
free(p->p_a);
p->p_a = NULL;
free(p);
p=NULL;
}
上述 代码1 和 代码2 可以完成同样的功能，但是方法1的实现有两个好处：
第⼀个好处是：方便内存释放
如果我们的代码是在⼀个给别人用的函数中，你在里面做了⼆次内存分配，并把整个结构体返回给用户。用户调⽤free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现fb这个事。所以，如果我们把结构体的内存以及其成员要的内存⼀次性分配好了，并返回给用户⼀个结构体指针，用户做⼀次free就可以把所有的内存也给释放掉。
第⼆个好处是：这样有利于访问速度.
连续的内存有益于
提⾼访问速度
，也有益于减少内存碎片。
我们也可以了解：C语⾔结构体⾥的数组和指针
七、总结C/C++中程序内存区域划分
C/C++程序内存分配的几个区域：
1.
栈区（stack）
：在执⾏函数时，函数内局部变量的存储单元都可以在栈上创建，函数执⾏结束时这些存储单元⾃动被释放。栈内存分配运算内置于处理器的指令集中，效率很⾼，但是分配的内
存容量有限。 栈区主要存放运⾏函数⽽分配的局部变量、函数参数、返回数据、返回地址等。
2.
堆区（heap）
：⼀般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配⽅式类似于链表。
3.
数据段（静态区）
（static）存放全局变量、静态数据。程序结束后由系统释放。
4.
代码段
：存放函数体（类成员函数和全局函数）的⼆进制代码。
总结
上述文章讲了C语言中的动态内存管理，希望对你有所帮助。
1974
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
