动态内存管理

0.前言

之前我们创建的变量大小都是固定的而且存在于栈，现在关于动态开辟的内存是存在堆区的，本篇就来学习一下动态内存管理。

1.为什么需要动态内存管理

先看看传统的开辟空间的方式

int i = 20;//在栈空间上开辟四个字节
char arr[10] = {0};//在栈空间连续开辟了10个字节

那上面这种方式开辟的空间有什么特点呢？
（1）内存大小是固定的。
（2）在开辟数组的时候必须指定开辟多少空间，后续不可变。

但很多时候我们不知道程序需要多少空间，如果用上述方法开辟空间，不能改变空间的大小，可能会面临开辟的空间不够或浪费空间的情况，这时候需要动态内存管理可以很好的解决上述问题。

2.动态内存函数的介绍

2.1malloc、free

c语言库里提供了动态开辟空间的函数malloc

void* malloc (size_t size);

（1）该函数的作用是开辟一块连续的空间并返回这块空间的起始地址。
（2）注意size的单位是字节数。
（3）注意返回值是void*，要根据实际情况强制转换 。
（4）假如因为内存不够开辟失败的话，该函数会返回NULL。
（5）假如你传参为0个字节的话，发生的事是未定义的，取决于你的编译器。

c语言库里还提供的释放和回收动态开辟空间的函数free

void free (void* ptr);

（1）该函数的作用是释放和回收动态开辟空间 。
（2）ptr是你要释放空间的起始地址。
（3）假如你传NULL过去，该函数什么事都不做。
（4）如果ptr指向的不是动态开辟的内存，该函数的行为是未定义的。

这两个函数的头文件都包含<stdlib.h>中。
使用例子

#include <stdio.h>
int main()
{
 //代码1
 int num = 0;
 scanf("%d", &num);
 int arr[num] = {0};
 //代码2
 int* ptr = NULL;
 ptr = (int*)malloc(num*sizeof(int));
 if(NULL != ptr)//判断ptr指针是否为空
 {
 int i = 0;
 for(i=0; i<num; i++)
 {
 *(ptr+i) = 0；
 }
 }
 free(ptr);//释放ptr所指向的动态内存
 ptr = NULL;//是否有必要？这一步是很有必要的，不然ptr就成为野指针。
 return 0;
}

2.2calloc

c语言库里提供了动态开辟空间的函calloc。

void* calloc (size_t num, size_t size);

（1）该函数的作用是开辟num个字节大小为size的连续空间
（2）和malloc函数不同的是，该函数会把内存空间初始化。

#include <stdio.h>
#include <stdlib.h>
int main()
{
 int *p = (int*)calloc(10, sizeof(int));
 if(NULL != p)
 {
 //使用空间
 }
 free(p);
 p = NULL;
 return 0;
}

2.3realloc

在我们使用malloc和calloc申请空间时，可能会觉得太大或太小了，而recalloc这个函数可以对申请的内存的大小作出灵活的调整。

void* realloc (void* ptr, size_t size);

（1）ptr是要调整的内存空间的地址
（2）size是调整之后的字节数的大小
（3）假如申请失败的话，该函数返回值是null
（4）返回值为调整之后的内存起始位置
（5）这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
（6）realloc在调整内存空间的是存在两种情况：
情况1：原有空间之后有足够大的空间，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化
情况2：原有空间之后没有足够大的空间，在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。

3.常见的内存动态错误

对动态内存的使用不当的话会造成很严重的后果，我们要了解可能出现的情况并且避免。

3.1 对NULL指针解引用

void test()
{
 int *p = (int *)malloc(INT_MAX/4);
 *p = 20;//如果p的值是NULL，就会有问题
 free(p);
}

3.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.3 对一块空间多次free

void test()
{
 int *p = (int *)malloc(100);
 free(p);
 free(p);//重复释放
}

3.4 free了非动态开辟的空间

void test()
{
 int a = 10;
 int *p = &a;
 free(p);//ok?
}

3.5 内存泄漏

void test()
{
 int *p = (int *)malloc(100);
 if(NULL != p)
 {
 *p = 20;
 }
}
int main()
{
 test();
 while(1);
}

3.6只释放了部分空间

void test()
{
 int *p = (int *)malloc(100);
 p++;
 free(p);//p不再指向动态内存的起始位置
}

4.经典笔试题

4.1

void GetMemory(char *p)
{
 p = (char *)malloc(100);
}
void Test(void)
{
 char *str = NULL;
 GetMemory(str);
 strcpy(str, "hello world");
 printf(str);
}

解析：传参是形参，并没有改变str的值，str仍然是空指针，在strcpy函数中造成了对空指针的解引用，而且GetMemory中申请的空间也没有释放掉，造成了内存释放。

4.2

char *GetMemory(void)
{
 char p[] = "hello world";
 return p;
}
void Test(void)
{
 char *str = NULL;
 str = GetMemory();
 printf(str);
}

解析：GetMemory函数中开辟内存的是静态内存，当函数结束后，系统会回收该处的空间，str指向的非法空间，是野指针，造成了非法访问。

4.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);
}

解析：这段代码可以正确的开辟动态内存，但是没有释放掉，造成了内存泄漏

4.4

void Test(void)
{
 char *str = (char *) malloc(100);
 strcpy(str, "hello");
 free(str);
 if(str != NULL)
 {
 strcpy(str, "world");
 printf(str);
 }
}

解析：该段代码free了之后，str变成了野指针，造成了非法访问。

5.c/c++内存区域划分

（1）栈区：在执行函数的时候，函数内的局部变量在栈区创建，在函数执行结束后，该部分的内存自动释放。栈区分配空间的效率很高，但是分配的内存的容量有限，所以栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
（2）堆区：一般由程序员自己手动释放，若程序员不释放，程序结束时可能由OS回收。
（3）数据段（静态区）：存放全局变量和静态变量。程序结束后由系统释放。
（4）代码段：存放函数体（类成员函数和全局函数）的二进制代码。

6.柔性数组

概念：C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员

typedef struct st_type
{
 int i;
 int a[];//柔性数组成员
}type_a;

6.1特点

（1）结构中的柔性数组成员前面必须至少一个其他成员。
（2）sizeof 返回的这种结构大小不包括柔性数组的内存。
（3）包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

typedef struct st_type
{
 int i;
 int a[0];//柔性数组成员
}type_a;
printf("%d\n", sizeof(type_a));//输出的是4，不包括柔性数组内存

6.2使用

//代码1
int i = 0;
type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));//这里是开辟了除了柔性数组的空间和100个整型元素的空间
//业务处理
p->i = 100;
for(i=0; i<100; i++)
{
 p->a[i] = i;
}
free(p);

6.3优点

第一个好处是：方便内存释放

如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。

第二个好处是：这样有利于访问速度.

连续的内存有益于提高访问速度，也有益于减少内存碎片。