动态内存管理

一、为什么存在动态内存分配

这是我们掌握的内存开辟：

int arr[10]={0};//在栈上开辟40个字节空间
int num=0;//在栈上开辟4个字节空间

但是上述的开辟空间的方式有两个特点：

1. 空间开辟大小是固定的。
2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。
但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，
那数组的编译时开辟空间的方式就不能满足了。
这时就需要动态开辟内存。

二、动态内存函数介绍

补充：什么是野指针？

“野指针”指的是指针变量中的值是非法的内存地址，但“野指针”不是空指针（NULL），“野指针”指向的内存是不可用的，“野指针”往往会造成”内存越界、段错误“等问题

2.1 malloc（不会初始化）

#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
    //开辟十个整型
    int* arr = (int*)malloc(sizeof(int) * 10);
    if (NULL == arr)
    {
        printf("%s\n", strerror(errno));
        return 0;
    }
    //使用
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        *(arr + i) = i;
    }
    for (i = 0; i < 10; i++)
    {
        printf("%d ", arr[i]);
    }
    //释放
    free(arr);//free只能释放malloc，realloc，calloc开辟的空间
    arr = NULL;//当释放后，arr成了野指针，所以我们需要把arr置成NULL
    return 0;
}

2.2 calloc(会初始化为0)

#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
    //开辟十个整型
    int* arr = (int*)calloc(10, sizeof(int));
    if (NULL == arr)
    {
        printf("%s\n", strerror(errno));
        return 0;
    }
    //使用
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        printf("%d ", arr[i]);//打印10个0
    }
    //释放
    free(arr);//free只能释放malloc，realloc，calloc开辟或调整的空间
    arr = NULL;//当释放后，arr成了野指针，所以我们需要把arr置成NULL
    return 0;
}

2.3 realloc(不会初始化)

2.3.1 特点

1、可以开辟空间//当realloc的第一个参数为NULL时，realloc开辟空间
//int*arr=(int*)realloc(NULL,40);    
2、可以调整空间（两种情况）//当realloc的第一个参数不为NULL时，realloc调整空间
//int*ptr=(int*)realloc(p,80);

举例

2.3.2 开辟空间

//1开辟空间
#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
    //开辟十个整型
    int* arr = (int*)realloc(NULL, sizeof(int) * 10);
    if (NULL == arr)
    {
        printf("%s\n", strerror(errno));
        return 0;
    }

    //使用
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        *(arr + i) = i;
    }
    for (i = 0; i < 10; i++)
    {
        printf("%d ", arr[i]);
    }
    //释放
    free(arr);//free只能释放malloc，realloc，calloc开辟或调整的空间
    arr = NULL;//当释放后，arr成了野指针，所以我们需要把arr置成NULL
    return 0;
}

2.3.3 调整空间

//2调整空间
#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
    //开辟十个整型
    int* arr = (int*)calloc(10, sizeof(int));
    if (NULL == arr)
    {
        printf("%s\n", strerror(errno));
        return 0;
    }

    //使用
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        printf("%d ", *(arr+i));
    }

    //需要增容80
    int* ptr = (int*)realloc(arr, sizeof(int) * 20);

    //如果调整失败，防止NULL赋给arr
    if (NULL != ptr)
    {
        arr = ptr;
        ptr = NULL;
    }

    //继续使用
    for (i = 10; i < 20; i++)
    {
        *(arr + i) = i;
    }
    for (i = 10; i < 20; i++)
    {
        printf("%d ", *(arr+i));
    }
    //释放
    free(arr);//free只能释放malloc，realloc，calloc开辟或调整的空间
    arr = NULL;//当释放后，arr成了野指针，所以我们需要把arr置成NULL
    return 0;
}

realloc在调整空间时会有两种情况

1、

第一种情况，在我们使用realloc调整空间时，如果在原本动态开辟的空间后有足够的空间，那么就会接着扩展空间。返回指向原本开辟空间起始位置的地址。

2、

第二种情况，在我们使用realloc调整空间时，如果在原本动态开辟的空间后续的空间不够拓展，那么就会找到一块足够的空间，并把原本动态开辟的空间的内容复制过来，返回指向后开辟空间的起始位置的地址。

三、常见的动态内存错误

3.1 对NULL指针的解引用操作

#include<limits.h>//INT_MAX所需的头文件
#include<stdlib.h>
int main()
{
    int*p=(int*)malloc(INT_MAX);//开辟失败返回NULL
    if(p==NULL)
        return 0;
    int i=0;
    for(i=0;i<10;i++)
    {
        *(p+i)=i;
    }
    return 0;
}

3.2 对动态内存开辟的空间

#include<string.h>
#include<stdlib.h>
#include<stdio.h>
#include<errno.h>
int main()
{
    char*p=(char*)malloc(10*sizeof(char));
    if(p==NULL)
    {
        printf("%s\n",strerror(errno));
    }
    //使用
    int i=0;
    for(i=0;i<=10;i++)
    {
        *(p+i)=i;
    }
    free(p);
    p=NULL;
    return 0;
}

3.3 对非动态内存开辟的空间释放

int main()
{
    int a=10;
    int*p=&a;
    free(p);//错误，free只能释放malloc，realloc，calloc开辟或调整的空间
    p=NULL;
    
    return 0;
}

注：数据结构中的栈与内存中栈区不能划等号

3.4 使用free释放一块动态开辟内存的一部分

int main()
{
    int*p=(int*)malloc(sizeof(int)*10);
    if(p==NULL)
    {
        printf("%s\n",strerror(errno));
        return 0;
    }
    //使用
    int i=0;
    for(i=0;i<5;i++)
    {
        *P=i+1;
        p++;
    }
    //释放
    free(p);//p不指向动态内存的起始位置
    p=NULL;
    return 0;
}

3.5 对同一块内存的多次释放

int main()
{
    int*p=(int*)malloc(sizeof(int)*10);
    if(p==NULL)
    {
        printf("%s\n",strerror(errno));
        return 0;
    }
    //使用
    int i=0;
    for(i=0;i<5;i++)
    {
        *(P+i)=i+1;
    }
    //释放
    free(p);

    free(p);//错误，释放多次;若在第一次释放后，将p置为空指针，可再次释放
    return 0;
}

3.6 动态开辟内存忘记释放（内存泄漏）

void test()//忘记释放不再使用的动态开辟的空间会造成内存泄露
{
    int*p=(int*)malloc(100);
    if(NULL!=p)
    {
        *p=20;
    }
}

int main()
{
    test();
    while(1);
}

四、几个经典的笔试题

运行Test函数会有什么样的结果？

例题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;
}

答案：程序出错

1、strcpy函数的第一个参数是空指针（因为GetMemory函数传参时传的是指针的值，所以，str的内容不会改变）

2、动态开辟内存后，没有释放，会导致内存泄漏

例题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;
}

答案：程序错误

1、在GetMemory函数运行结束后，p变量会被销毁，把销毁的地址赋给str，再打印，会形成非法访问

例题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;
}

答案：打印hello
1、没有对动态内存开辟的空间进行释放，会导致内存泄漏

例题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;
}

答案：

1、在free（str）后，没有把str置为NULL

1、在str指向的空间释放后，不能再次使用，会形成非法访问内存。

五、C/C++程序的内存开辟

C/C++程序内存分配的几个区域：

1、栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

2、堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。

3、数据段（静态区）：存放全局变量、静态数据。程序结束后由系统释放。

4、代码段：存放函数体（类成员函数和全局函数）的二进制代码。

六、柔性数组

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

例如：

//1
struct s1
{
    int n;
    int arr[0];//大小是未指定的
};
//2 对于某些编译器第一种写法会报错无法编译可以采用第二种写法
struct s2
{
    int n;
    int arr[];
};

6.1 柔性数组的特点

• 结构中的柔性数组成员前面必须至少一个其他成员。
• sizeof 返回的这种结构大小不包括柔性数组的内存。
• 包含柔性数组成员的结构用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));
//使用
p->i = 100;
for(i=0; i<100; i++)
{
    p->a[i] = i;
}
free(p);

这样柔性数组成员a，相当于获得了100个整型元素的连续空间。

6.3 柔性数组的优势

上述的 type_a 结构也可以设计为：

//代码2
typedef struct st_type
{
    int i;
    int *p_a;
}type_a;
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：

代码1在内存开辟空间的情况，如上图

在代码1的情况，malloc一次type_a类型结构体即可。

代码2：

代码2在内存开辟空间的情况，如上图

代码2若想达到代码一的效果，需要先malloc type_a类型的结构体，再malloc一段连续的空间，这需要进行两次malloc，也需要两次free，同时这有也会产生内存碎片。

总结：

上述 代码1 和 代码2 可以完成同样的功能，但是 方法1 的实现有两个好处 ：

第一个好处是：方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
第二个好处是：这样有利于访问速度.
连续的内存有益于提高访问速度，也有益于减少内存碎片。