【C语言】—— 动态内存管理
【C语言】——动态内存管理
- 一、动态内存管理概述
- 1.1、动态内存的概念
- 1.2、动态内存的必要性
- 二、
m
a
l
l
o
c
malloc
malloc 函数 - 2.1、函数介绍
- 2.2、应用举例
- 三、
c
a
l
l
o
c
calloc
calloc 函数 - 四、
f
r
e
e
free
free 函数 - 4.1、函数介绍
- 4.2、应用举例
- 五、
r
e
a
l
l
o
c
realloc
realloc 函数 - 5.1、函数介绍
- 5.2、应用举例
- 六、常见的动态内存错误
- 6.1、对NULL指针进行解引用
- 6.2、对动态开辟空间的越界访问
- 6.3、对非动态开辟的内存使用
f
r
e
e
free
free 释放 - 6.4、使用
f
r
e
e
free
free 释放一块动态开辟内存的一部分 - 6.5、对同一块动态内存多重释放
- 6.6、动态开辟内存忘记释放（内存泄漏）
- 七、动态内存经典笔试题分析
- 7.1、题一
- 7.2、题二
- 7.3、题三
- 7.4、题四
- 八、柔性数组
- 8.1、什么是柔性数组
- 8.2、柔性数组的特点
- 8.2、柔性数组的使用
- 8.3、柔性数组的优势
- 九、C/C++中内存区域划分
一、动态内存管理概述
1.1、动态内存的概念
在了解为什么要有动态内存管理之前，我们得先知道动态内存的定义。
动态内存是指动态的内存空间，意思就是：能动态开辟的内存空间，动态就是申请了这块空间后，可动态的修改这块空间的大小，根据需要，动态地释放和分配内存空间。
1.2、动态内存的必要性
为什么要有动态内存呢？
既然有动态内存，那与之相对的就是静态内存
什么是静态内存呢？其实静态内存我们天天都在用，只是不知道它是静态内存而已
下面两种内存开辟方式就是静态内存
int val = 20;//在栈空间上开辟四个字节
char arr[10] = { 0 };//在栈空间上开辟10个字节的连续空间
但是静态内存的开辟有两个缺点：
- 空间开辟的大小是固定的
- 数组在申明的时候，必须指定数组的长度，数组空间一旦确定了大小不能调整
但是，在实际需求中，我们往往只有在程序运行时才能知道所需的空间大小，用数组开辟空间，往往容易造成内存溢出（空间开小），或者内存浪费（空间开大），无法满足实际的需求
因此，C语言引入了动态内存开辟，让程序员自己可以申请和释放空间，并根据需要，自己调整开辟后空间的大小。这样不仅提高了内存的利用率，也极大地增强了程序的灵活性与扩展性。
二、 m
a
l
l
o
c
malloc
malloc 函数
2.1、函数介绍
C语言中提供了一个动态内存分配的函数：
m
a
l
l
o
c
malloc
malloc
功能：向内存申请一块连续可用的空间（可当成数组），并返回指向这块空间的指针
参数
s
i
z
e
size
size_
t
t
t
s
i
z
e
size
size：
- 分配的
内存的大小，以字节为单位。即开辟s
i
z
e
size
size 字节大小的空间 - 如果参数为
0，m
a
l
l
o
c
malloc
malloc 的行为是标准未定义的，取决于编译器
- 分配的
返回值
v
o
i
d
void
void *：
- 返回指向开辟空间的指针，因为
m
a
l
l
o
c
malloc
malloc 函数 事先并不知道使用者开辟空间存放什么类型的数据，因此指针为v
o
i
d
void
void* 类型，以便能接受所有类型。 - 使用者可根据自己的需要，将其强制类型转换成自己所需要的类型，以便能进行解引用操作。
- 如果开辟失败，则返回 空指针，因此
m
a
l
l
o
c
malloc
malloc 的返回值一定要做检查
- 返回指向开辟空间的指针，因为
2.2、应用举例
#include
int main()
{
int* p = NULL;
p = (int*)malloc(10 * sizeof(int));
if (NULL == p)
{
perror("malloc fail");
return 1;
}
return 0;
}
上述代码是使用
m
a
l
l
o
c
malloc
malloc 函数开辟 10 个整型变量的空间，也即 40 个字节的空间
- 首先，因为
m
a
l
l
o
c
malloc
malloc 函数的返回值是指针，我们需用指针变量p
p
p 接收其返回值，创建p
p
p 时，并不知道其指向的空间，所以先初始化为 NULL。 - 接着，使用
m
a
l
l
o
c
malloc
malloc 函数开辟空间，因为我们要存放的是整型变量，而m
a
l
l
o
c
malloc
malloc 的返回值类型为v
o
i
d
void
void* 我们通过强制类型转换将其返回类型转换为i
n
t
int
int* ，并用p
p
p 来接收 - 因为
m
a
l
l
o
c
malloc
malloc 函数有可能开辟失败1，只有当返回值不为空的情况我们才使用它，因此需判断p
p
p 指针是否为空。若为空，则用p
e
r
r
o
r
perror
perror 函数2打印出错误信息，并返回 13。 - 若开辟成功，我们就可以愉快地使用这块空间啦
需要注意的是：
m
a
l
l
o
c
malloc
malloc 开辟的空间并不会将其初始化
三、 c
a
l
l
o
c
calloc
calloc 函数
开辟动态内存空间，C语言还提供了一个函数叫
c
a
l
l
o
c
calloc
calloc ，原型如下：
- 函数的功能是为
n
u
m
num
num 个大小为s
i
z
e
size
size 的元素开辟一块空间，并将这块空间初始化为 0 - 与函数
m
a
l
l
o
c
malloc
malloc 的区别只在于c
a
l
l
o
c
calloc
calloc 会返回地址之前把申请的空间的每个字节初始化为全 0
举个例子：
#include
#include
int main()
{
int* p = (int*)calloc(10, sizeof(int));
if (NULL != p)
{
int i = 0;
for (i = 0; i < 10; i++)
{
printf(" %d", *(p + i));
}
printf("
");
}
return 0;
}
运行结果：
四、 f
r
e
e
free
free 函数
4.1、函数介绍
上述
m
a
l
l
o
c
malloc
malloc 函数、
c
a
l
l
o
c
calloc
calloc 函数以及后面讲的
r
e
a
l
l
o
c
realloc
realloc 函数所申请的空间，并不满足作用域的规则。只有当程序退出时，用他们开辟的动态空间才会归还给操作系统，换言之，程序不退出，就不会主动归还空间。这时，我们就需要
f
r
e
e
free
free函数 来对其主动释放
f
r
e
e
free
free 函数是专门用于动态开辟的内存空间的释放和回收，声明如下：
f
r
e
e
free
free 函数用来释放动态开辟的内存
- 如果参数
p
t
r
ptr
ptr 指向的空间不是动态开辟的，那f
r
e
e
free
free 函数的行为是未定义的 - 如果参数是
p
t
r
ptr
ptr 是NULL指针，则函数什么事都不做 - 需要注意的是，
f
r
e
e
free
free 函数不会改变指针所指向的值，释放后它依然指向相同的内存空间。因此我们要手动将释放后的p
t
r
ptr
ptr 置空，避免出现野指针。
m
a
l
l
o
c
malloc
malloc、
c
a
l
l
o
c
calloc
calloc 以及
f
r
e
e
free
free 函数的声明都在
<stdlib.h> 中
4.2、应用举例
我们来看个例子：
#include
#include
int main()
{
int* ptr = NULL;
ptr = (int*)malloc(10 * sizeof(int));
if (NULL != ptr)
{
int i = 0;
for (i = 0; i < 10; i++)
{
*(ptr + i) = 0;
}
}
free(ptr);
ptr = NULL;
return 0;
}
那我们来看看下面这种情况行不行呢？
int main()
{
int* ptr = NULL;
ptr = (int*)malloc(5 * sizeof(int));
if (NULL != ptr)
{
int i = 0;
for (i = 0; i < 5; i++)
{
*ptr = 0;
ptr++;
}
}
free(ptr);
ptr = NULL;
return 0;
}
当然是不行的，为什么呢？
因为传递给
f
r
e
e
free
free 函数的是要释放空间的 起始地址
上面函数的
p
t
r
ptr
ptr 以及不再指向要释放空间的起始地址了，当然是不行的。
五、 r
e
a
l
l
o
c
realloc
realloc 函数
5.1、函数介绍
可能有小伙伴问：前面你说动态内存可根据需要，动态调整所开辟空间的大小，但前面介绍
m
a
l
l
o
c
malloc
malloc、
c
a
l
l
o
c
calloc
calloc 以及
f
r
e
e
free
free函数 都只是在将动态空间的开辟和释放，如何调整空间的大小呢？别急，我们接下来要讲的
r
e
l
l
o
c
relloc
relloc函数 就是完成调整开辟空间的大小的任务的
r
e
a
l
l
o
c
realloc
realloc 函数的出现让动态内存管理更加灵活
有时我们会发现之前申请的空间太小了，有时我们又会觉得申请的空间太大了，那为了合理的使用内存，，我们一定会对内存的大小做出灵活的调整。那
r
e
a
l
l
o
c
realloc
realloc函数 就可以做到对动态开辟内存大小的调整
先来看看
r
e
l
l
o
c
relloc
relloc函数 的声明：
p
t
r
ptr
ptr 是要调整的内存地址s
i
z
e
size
size 是调整之后的大小（可以变大，也可变小）- 返回值为调整之后的内存起始位置
r
e
a
l
l
o
c
realloc
realloc 调整内存大小分为三种情况：
- 原有空间之后有足够大的空间
如上图：
r
e
l
l
o
c
relloc
relloc 已经开辟 20 个字节的空间，现在我想扩容到 40 字节，同时
原有空间后方空间足够扩展新空间
此时r
e
a
l
l
o
c
realloc
realloc 函数直接在后方追加空间，原来空间的数据不发生变化
2. 原有空间之后没有足够大的空间
还是上面那个图，现在我想将他扩容到 400 字节，很明显，已开辟空间
后方没有足够的空间，总不能把别人踢开，自己霸占吧
这时，r
e
a
l
l
o
c
realloc
realloc 函数就会在堆空间 另外找一个 合适大小的空间。
具体流程如下：
r
e
a
l
l
o
c
realloc
realloc 函数先在堆空间上找一块新的空间，并且满足大小要求
- 后将旧空间的数据拷贝到新空间中
- 接着释放旧空间
- 最后返回新空间的起始地址
3. 空间调整失败
r
e
a
l
l
o
c
realloc
realloc 可能出现空间调整失败的情况，此时返回的是空指针
r
e
a
l
l
o
c
realloc
realloc 不仅仅能将空间的变大，还能将空间变小，只需要第二个参数的值小于原空间的大小就好了，因为缩小空间比较简单，这里就不再过多介绍，但需要注意的是，缩小空间可能会造成数据丢失，因此需小心使用
同时
r
e
a
l
l
o
c
realloc
realloc函数 不仅能调整空间大小，还能完成
m
a
l
l
o
c
malloc
malloc函数 的功能：当第一个参数
p
t
r
ptr
ptr 传递的是 空指针 时，
r
e
a
l
l
o
c
realloc
realloc 函数就不再是调整空间大小了，你都没空间，我还怎么调。此时
r
e
a
l
l
o
c
realloc
realloc 函数会 新开辟
s
i
z
e
size
size 字节大小的空间。
5.2、应用举例
看了上面三种情况，大家想一想，应该怎样接收
r
e
a
l
l
o
c
realloc
realloc 调整之后的返回值呢？
可以直接用原来的指针
p
p
p 接收吗？
显然是不行，如果
r
e
a
l
l
o
c
realloc
realloc 调整成功，那确实没问题，但如果失败了呢？此时返回的是空指针。本来
p
p
p 还维护着原来的空间，现在直接变空指针，那原来的空间再也找不到了，这就造成了内存泄漏。
正确的方法是创建新的指针
p
t
r
ptr
ptr 来接收，当
p
t
r
ptr
ptr 不为 NULL，再将
p
t
r
ptr
ptr 的值传给
p
p
p
如下：
#include
int main()
{
int* p = (int*)malloc(5 * sizeof(int));
if (NULL == p)
{
perror("malloc fail");
return 1;
}
//1 2 3 4 5
for (int i = 0; i < 5; i++)
{
*(p + i) = i + 1;
}
//希望将空间调整为40个字节
int* ptr = NULL;
ptr = (int*)realloc(p, 40);
if (NULL != ptr)
{
p = ptr;
}
else
{
perror("realloc fail");
}
//调整成功，使用40个字节；调整失败，继续使用20个字节
/**************
业务处理
**************/
free(p);
p = NULL;
return 0;
}
六、常见的动态内存错误
6.1、对NULL指针进行解引用
#include
int main(
{
int* p = (int*)malloc(INT_MAX);
*p = 20;//如果p的值是空指针，就会有问题
free(p);
p = NULL;
return 0;
}
动态开辟的空间，应该先对返回值进行判断，确保空间开辟成功
上述代码所要开辟的空间太大，开辟失败，返回的是空指针，而下面一句代码对空指针进行解引用，是错误的
#include
int main()
{
int* p = (int*)malloc(10 * INT_MAX);
if (NULL == p)
{
perror("malloc fail");
return 1;
}
*p = 20;
free(p);
p = NULL;
return 0;
}
6.2、对动态开辟空间的越界访问
#include
int mian()
{
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;
}
free(p);
p = NULL;
return 0;
}
可以看到，当
i
i
i = 10 时，就是对
m
a
l
l
o
c
malloc
malloc 开辟的空间越界访问了。
动态内存的空间与数组是非常相似的，要注意不能对其越界访问。
6.3、对非动态开辟的内存使用 f
r
e
e
free
free 释放
void test()
{
int a = 10;
int* p = &a;
free(p);//ok?
}
变量
a
a
a 并不是动态开辟的变量，用
f
r
e
e
free
free 释放是错误的
6.4、使用 f
r
e
e
free
free 释放一块动态开辟内存的一部分
这种情况即是，传给
f
r
e
e
free
free 的指针并不是动态开辟内存的起始地址，指针跑后面去了。
void test()
{
int* p = (int*)malloc(100);
p++;
free(p);//p不再指向动态内存的起始位置
}
注意：动态内存一定是 一同申请，一同释放。无法做到只释放一部分空间
6.5、对同一块动态内存多重释放
void test()
{
int* p = (int*)malloc(100);
//···
free(p);
free(p);//重复释放
}
这种释放有办法可以避免：释放完后及时把
p
p
p 置为空指针，这样，即使再次释放，传的是空指针，
f
r
e
e
free
free 什么都不会做，不会造成什么影响
6.6、动态开辟内存忘记释放（内存泄漏）
#include
void test()
{
int* p = (int*)malloc(100);
if (NULL != p)
{
*p = 20;
}
}
int main()
{
test();
while (1);
return 0;
}
上述代码，你会发现，一旦出了函数，就再也找不到开辟的那 100 个字节的空间(这代码写的比较极端，一直死循环，程序一直不结束) 。找不到开辟的空间更别提将其释放，空间就一直在那占着，就造成了内存泄漏。
想一想，如果我们一直向内存申请空间，但从来不释放。要知道，内存的总大小是有限的，这样就会把内存耗干，机器就挂了。
总结： 用
m
a
l
l
o
c
malloc
malloc、
c
a
l
l
o
c
calloc
calloc、
r
e
a
l
l
o
c
realloc
realloc 申请的空间，尽量做到：
谁（可能是函数）申请的就谁释放，即m
a
l
l
o
c
malloc
malloc 和f
r
e
e
free
free 成对出现- 如果不能释放，要
告诉使用的人记得释放
七、动态内存经典笔试题分析
7.1、题一
void GetMemory(char* p)
{
p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}
int main()
{
Test();
return 0;
}
请问运行
T
e
s
t
Test
Test 函数会有什么样的结果？
运行
T
e
s
t
Test
Test 函数，程序会崩溃！
为什么呢？我们来分析一下
先来看这段代码想要做什么：
- 首先，它定义了一个
G
e
t
M
e
m
o
r
y
GetMemory
GetMemory函数，很明显，这个函数是完成动态开辟空间任务的
- 接着
T
e
s
t
Test
Test函数 中创建了指针
s
t
r
str
str，将变量传给
G
e
t
M
e
m
o
r
y
GetMemory
GetMemory，即希望指针
s
t
r
str
str 管理动态开辟的空间
- 最后往空间中存入
”
h
e
l
l
o
w
o
r
l
d
”
“hello world”
“helloworld“，并打印
代码的逻辑没问题，那就是代码本身出问题咯
通过调试我们发现，
G
e
t
M
e
m
o
r
y
GetMemory
GetMemory函数 并没有改变
s
t
r
str
str 的值，它依然是个空指针。
为什么呢？因为
G
e
t
M
e
m
o
r
y
GetMemory
GetMemory是 传值传参，而不是传址传参！传值传参无法改变主调函数中的值，出了函数
s
t
r
str
str 依然是空指针，而后面打印
s
t
r
str
str 指向的内容，是要对其解引用的，对空指针解引用自然会出问题。
同时，函数中
m
a
l
l
o
c
malloc
malloc 是实打实开辟了空间的，只有程序结束才销毁，而函数中的变量出了函数作用域就销毁，这样函数中所开辟的 100 个字节空间出了
G
e
t
M
e
m
o
r
y
GetMemory
GetMemory函数 后也无法找到，造成内存泄漏=
可能有小伙伴会问：
G
e
t
M
e
m
o
r
y
GetMemory
GetMemory函数 的参数类型就是
c
h
a
r
char
char* 啊，为什么还是传值传参呢？这里我们要指针传址传参的本质：传递的是变量的地址，因为主调函数中要传的值本身就是指针
c
h
a
r
char
char* 类型，要改变指针变量，就要传递指针变量的指针，即二级指针。这里可不敢看到
G
e
t
M
e
m
o
r
y
GetMemory
GetMemory函数 参数中是
c
h
a
r
char
char* 就认为他是传址传参
正确写法应该是这样：
void GetMemory(char** p)
{
*p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
//传str的地址
GetMemory(&str);
strcpy(str, "hello world");
printf(str);
//释放动态空间
free(str);
str = NULL;
}
当然，
G
e
t
M
e
m
o
r
y
GetMemory
GetMemory函数 我们也可以直接让他返回
p
p
p，以实现目的
char* GetMemory()
{
char* p = (char*)malloc(100);
return p;
}
void Test(void)
{
char* str = GetMemory();
strcpy(str, "hello world");
printf(str);
free(str);
str = NULL;
}
7.2、题二
char* GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory();
printf(str);
}
int main()
{
Test();
return 0;
}
运行结果：
为什么会这样呢？
问题还是出在
G
e
t
M
e
m
o
r
y
GetMemory
GetMemory函数
G
e
t
M
e
m
o
r
y
GetMemory
GetMemory函数 中创建的
p
p
p 数组，在出了函数作用域后就销毁了，因此函数返回
p
p
p，用
s
t
r
str
str 接收，而实际上
s
t
r
str
str 接收的地址是指向一块已经归还的空间，此时的
s
t
r
str
str 是野指针。再去访问
s
t
r
str
str 所指向的空间是非法访问，打印出的值是随机值。
7.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);
}
int main()
{
Test();
return 0;
}
可能有小伙伴会觉得这段代码咋一看好像没什么问题啊
确实，大家有没有发现代码与我们第一题修改后的代码非常像，但大家仔细想想它还缺少什么？
这段代码唯一的问题是：没有
f
r
e
e
free
free，动态申请内存空间后他并没有还回去。
虽然这里没有
f
r
e
e
free
free 程序也没有问题，因此程序结束后会自动释放空间，但以后遇到复杂的情况就不好说了，因此我们要 养成主动释放内存空间的习惯
7.4、题四
void Test(void)
{
char* str = (char*)malloc(100);
strcpy(str, "hello");
free(str);
if (str != NULL)
{
strcpy(str, "world");
printf(str);
}
}
int main()
{
Test();
return 0;
}
这题的问题相信大家都能看得出来：
T
e
s
t
Test
Test函数 上来先开辟 100 字节动态空间，并创建
s
t
r
str
str 变量维护它，再向空间中放
”
h
e
l
l
o
”
“hello”
“hello“
但紧接着，释放
s
t
r
str
str，却没将
s
t
r
str
str 置空，此时的
s
t
r
str
str是野指针。将空间释放，即将其还给操作系统，我们是没有使用权限了，但是这块空间本身还在
下面的
i
f
if
if 语句判断为真，往
s
t
r
str
str 指向的空间放入
”
w
o
r
l
d
”
“world”
“world“，此时
s
t
r
str
str 指向的空间我们已经没有使用权限了，但依然进行修改，为非法内存访问。
八、柔性数组
8.1、什么是柔性数组
也许有些小伙伴从来没有听过柔性数组这个概念，但是它确实是存在的
C99 中，结构体的最后一个元素允许是未知大小的数组，这就叫做：柔性数组成员。
typedef struct st_type
{
int i;
int a[0];
}type_a;
有些编译器会报错无法编译，可以改成：
typedef struct st_type
{
int i;
int a[];
}type_a;
8.2、柔性数组的特点
- 结构体中的柔性数组成员
前面必须至少一个其他成员 s
i
z
e
o
f
sizeof
sizeof 返回的这种结构体大小不包括柔性数组的内存- 包含柔性数组成员的结构体一般用
m
a
l
l
o
c
malloc
malloc函数 进行内存的动态分配，并且分配的内存应该大于结构体的大小，以适应柔性数组的预期大小
例如：
typedef struct st_type
{
int i;
int a[0];
}type_a;
int main()
{
printf("%d
", sizeof(type_a));
return 0;
}
运行结果：
8.2、柔性数组的使用
#include
#include
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) + 10 * sizeof(int));
if (NULL == p)
{
perror("malloc fail");
return 1;
}
//业务处理
p->i = 10;
for (i = 0; i < 10; i++)
{
p->a[i] = i;
}
//调整空间
type_a* ptr = (type_a*)realloc(p, sizeof(type_a) + 20 * sizeof(int));
if (ptr != NULL)
{
p = ptr;
}
free(p);
p = NULL;
return 0;
}
柔性数组的结构：
既然这块空间是
m
a
l
l
o
c
malloc
malloc 出来的，也就是说他可以通过
r
e
a
l
l
o
c
realloc
realloc 来调整大小，所以这个数组可变长变短，不就是柔性吗
8.3、柔性数组的优势
上述
t
y
p
e
type
type_
a
a
a 结构，也可以设计为下面的结构，也能完成同样的效果
#include
#include
typedef struct st_type
{
int i;
int* p_a;
}st_type;
int main()
{
st_type* p = (st_type*)malloc(sizeof(st_type));
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;
return 0;
}
图示：
上述两个方法都可以达到类似的效果
但是使用柔性数组有两个好处：
- 方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把结构体返回给用户。用户调用f
r
e
e
free
free 可以释放结构体，但是用户并不知道结构体内的成员也需要f
r
e
e
free
free，所以你不能指望用户来发现这个事。
所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次f
r
e
e
free
free 就可以把所有的内存释放掉
- 有利于访问速度
连续的内存有益于提高访问速度，也有益于减少内存碎片4
九、C/C++中内存区域划分
C/C++程序内存分配的几个区域
内核空间：操作系统核心（内核）运行的地方，在这个区域，操作系统可以直接访问硬件，并执行特权指令。我们用户是无权访问这块空间的栈区：在执行函数时，函数内局部变量的存储单元都是在栈上创建，函数执行结束时这些存储单元自动释放。栈内存分配运算内置于处理器的指令中，效率很高，但是分配的内存容量有限。栈区只要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。堆区：堆区一般是用来存储程序运行期间动态分配内存的地方。堆区的内存分配是在程序运行时动态进行的，程序员可以通过调用标准库函数（如m
a
l
l
o
c
malloc
malloc、c
a
l
l
o
c
calloc
calloc、r
e
a
l
l
o
c
realloc
realloc等）来在堆区中分配内存，并在不需要时手动释放这些内存（使用f
r
e
e
free
free函数）。使用堆区需要注意内存泄漏（m
e
m
o
r
y
l
e
a
k
memory leak
memoryleak）的问题，即程序在不再需要某块内存时没有释放它，导致程序占用的内存越来越多。数据段：数据段也叫做静态区，主要用来存放全局变量、静态数据、全局变量。程序结束后由系统释放代码段：存放函数体（类成员函数和全局函数）的二进制代码、只读常量（字符串常量）
内存开辟失败：动态内存开辟失败的原因一般都是所空间太大，没有足够的空间 ↩︎
p
e
r
r
o
r
perror
perror函数：有关该函数的具体介绍请看：《【C语言】——字符串函数的使用与模拟实现（下）》 ↩︎
返回值为 1：
m
a
i
n
main
main 函数程序正常退出，返回值为 0；异常退出，返回值为 1 ↩︎
我们开辟内存时，不会紧接着上一块内存开辟，而会留下一点空隙，开辟次数越多，留下的空隙也就也多，这些空隙称为内存碎片。 ↩︎
