:key: 引：为什么存在动态内存分配？

我们已经掌握的内存开辟方式有：

int a = 0;//4byte
int arr[10] = { 0 };//40byte

这样的开辟方式---

开辟空间大小是固定的，想大不能大，想小不能小；
定义数组时，必须给定大小，然而有时我们需要的空间大小在编译时才会知道。

在这里插入图片描述
由此引入动态内存开辟，这就要学习动态内存函数。

正文开始@一个人的乐队

1. 动态内存函数的介绍

1.1 malloc和free

1.1.1 malloc

C语言提供了一个动态内存开辟的函数:（头文件：#include<stdlib.h>）

void* malloc (size_t size);

void*:这块内存是为谁申请的也不知道，返回什么类型也不合适，那就返回通用类型。

size：要申请的字节数。

作为malloc函数的使用者，我很清楚我申请的内存空间要来做什么，在使用时要做强制类型转换:

int* ptr = (int*)malloc(10 * sizeof(int));

:yellow_heart:功能：在堆区上申请size个字节的空间，并返回堆区上的起始地址。

若开辟成功，返回一个指向开辟好空间的指针；

若开辟失败，则返回空指针NULL。

:snowflake:因此，malloc的返回值一定一定要做检查！！！

1.1.2 搭配使用的free

C语言提供了另外一个函数用于做动态内存释放和回收的:
(头文件:#include<stdlib.h>)

void free(void* ptr);

:yellow_heart:功能：把ptr所指向的空间还给操作系统

注：

:snowflake:1. 若参数 ptr指向的空间 不是动态开辟的，则 free函数的行为是 标准未定义的。
:snowflake:2. 若参数 ptr是 NULL空指针，即 free(NULL); okay,只不过 什么都不干。

上代码感受它们的使用：
思考：free(ptr);后的ptr == NULL;是否有必要？

#include<stdio.h>
#include<stdlib.h>

int main()
{
    //申请空间
    int* p = (int*)malloc(10 * sizeof(int));
    if (p == NULL)
    {
        return -1;
    }
    //使用
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        *(p + i) = i;
    }
    //释放ptr指向的这段内存
    free(p);
    //p = NULL;//是否有必要？
    return 0;
}

调试起来：
在这里插入图片描述
可以看到ptr指向的这段空间虽然释放了，但ptr依然指向这段空间（也就是说free根本就不会使ptr发生改变，也不会将ptr主动置空）。

此时ptr是野指针，很危险，就一定要ptr == NULL;，让ptr永远也找不到这段空间。

:snowflake:3. 释放 ptr指向的内存空间后 free(ptr);，一定要 将ptr置空 ptr==NULL。

1.2 calloc

C语言还提供了一个calloc函数，也可用来动态内存分配:
(头文件:#include<stdlib.h>)

void* calloc (size_t num, size_t size);

void*:空类型，为了适应各种指针类型，以便正确解引用

num:要申请的元素个数

size:元素大小

:yellow_heart:功能：为大小为size的num个元素开辟一块空间，并将每一个字节都初始化为0.

若开辟成功，则返回开辟好空间的起始地址

若开辟失败，则返回空指针NULL

:snowflake:因此，与malloc一样,对于calloc的返回值也一定一定要做检查！！！

上代码感受：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>

int main()
{
    //申请10个int的空间
    int* p = (int*)calloc(10, sizeof(int));
    if (p == NULL)
    {
        printf("%s", strerror(errno));//错误码翻译出错误信息
        return -1;
    }
    //申请成功
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        printf("%d ", *(p + i));//打印
    }
    //释放
    free(p);
    p = NULL;
    return 0;
}

运行+调试结果：
在这里插入图片描述
演示申请空间失败的情况，申请空间过大：

对比malloc和calloc:

:snowflake: malloc:只负责在堆区申请空间，并返回起始地址， 不会初始化空间
:snowflake: calloc:在堆区申请空间， 初始化为0，并返回起始地址
以后也很简单，我要初始化我就用calloc,不想初始化我就用malloc.

1.3 realloc

有时我们发现过去申请的内存太小/过大了，为了合理使用内存就一定要对内存大小进行调整。
realloc函数的出现，让动态内存管理更加灵活.(头文件:#include<stdio.h>)

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

ptr:要调整的内存地址

size:调整后的新大小

void*:调整后的内存起始地址

:snowflake:realloc在调整内存空间时存在两种情况：

:purple_heart:情况1：原空间后有足够大的空间

:purple_heart:情况2：原空间后没有足够大的空间

:yellow_heart:这个函数在调整原内存空间大小的同时，还会将原内存中的数据移动到新的空间中去。

上代码感受：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>

int main()
{
    int* p= (int*)malloc(10 * sizeof(int));
    if (p == NULL)
    {
        printf("%s\n", strerror(errno));
        return -1;
    }
    //申请成功
    //使用
    //...
    //空间不够，增加空间至20int
    int* ptr = (int*)realloc(p, 20 * sizeof(int));//用新指针来接收
    if (ptr == NULL)
    {
        return -1;
    }
    else
    {
        p = ptr;
    }
    
    int i = 0;
    for (i = 0; i < 20; i++)
    {
        *(p + i) = i;
    }
    //打印
    for (i = 0; i < 20; i++)
    {
        printf("%d ", *(p + i));
    }
    
    //释放
    free(p);
    p = NULL;
    return 0;
}

:heart:注: 为什么这里一定要用新指针来接收：

//空间不够，增加空间至20int
int* ptr = (int*)realloc(p, 20 * sizeof(int));//用新指针来接收

//若仍用旧指针p来接收
int* p = (int*)realloc(p, 20 * sizeof(int));

不可，因为，若内存申请失败返回NULL，则原来p指向的空间也找不到了。

2. 常见动态内存错误

下面再次强化常见动态内存分配的错误点，以后都要避免奥。

2.1 对动态开辟的空间越界访问

#include<stdio.h>
#include<stdlib.h>

void test()
{
    int* p = (int*)malloc(10 * sizeof(int));
    if (p == NULL)
    {
        return ;
    }
    //使用
    int i = 0;
    for (i = 0; i <= 10; i++)
    {
        *(p + i) = i;
    }
    //释放
    free(p);
    p = NULL;
}
int main()
{
    test();
    return 0;
}

运行结果：挂了:cold_sweat:
在这里插入图片描述

2.2 对NULL指针解引用

void test()
{
     int *p = (int *)malloc(INT_MAX/4);
     *p = 20;
     free(p);
}

直接这样写代码是有风险的，若malloc申请内存空间失败，则返回NULL，*p = 20;则是对空指针解引用。
这就要求我们在申请空间后一定要进行判断，先判断，再使用。

:white_check_mark: 更正--- 在申请空间后 一定要进行判断

void test()
{
     int *p = (int *)malloc(INT_MAX/4);
     if(p == NULL)
     {
         return;
     }
     *p = 20;
     free(p);
}

2.3 对非动态开辟的内存用free释放

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

运行结果 --- 又挂了:cold_sweat:
在这里插入图片描述

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

上代码：

#include<stdio.h>
#include<stdlib.h>

int main()
{
    int* p = (int*)malloc(10 * sizeof(int));
    if (p == NULL)
    {
        return -1;
    }
    //使用
    int i = 0;
    for (i = 0; i < 5; i++)
    {
        *p++ = i;
    }
    //释放
    free(p);
    p = NULL;
    return 0;
}

运行结果---又挂了:cold_sweat:
在这里插入图片描述

:white_check_mark:传给 free的，必须是动态开辟 内存的起始位置。

2.5 对同一块内存多次释放

#include<stdio.h>
#include<stdlib.h>

int main()
{
    int* p = (int*)malloc(10 * sizeof(int));
    free(p);
    free(p);//重复释放
    return 0;
}

运行结果---又挂了:cold_sweat:
在这里插入图片描述

:white_check_mark:更正：在 free释放 p指向的空间后，记得 将p置空 p = NULL;

#include<stdio.h>
#include<stdlib.h>

int main()
{
    int* p = (int*)malloc(10 * sizeof(int));
    free(p);
    p = NULL;
    free(p);//p为NULL，okay,只不过什么也不做
    p = NULL;
    return 0;
}

2.6 动态开辟的内存忘记释放(内存泄漏)

在堆区上申请的动态内存空间有两种回收方式：

主动free掉
当程序退出时，申请的空间也会回收

思考：

#include<stdio.h>
#include<stdlib.h>

int main()
{
    int* p = (int*)malloc(10 * sizeof(int));
    if (p == NULL)
    {
        return -1;
    }
    //使用
    //忘记释放了
    getchar();
    return 0;
}

运行起来，光标闪烁，getchar();等待接收字符，程序不结束，如果这段空间不被释放，造成了内存泄漏。

忘记释放不再使用的动态开辟的空间会造成内存泄漏---这块空间你又不用你又不释放，别人也无法使用，如果服务器7*24小时的在跑，那非常可怕，内存会被一点一点耗干。

:white_check_mark:动态开辟的内存空间，一定要释放，且要正确释放。

3. 经典笔试题

3.1 笔试题1

上代码思考：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

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

运行结果---挂了:cold_sweat:
在这里插入图片描述

:key:解析:

在这里插入图片描述

:fish:1°程序崩溃

①str传给p是值传递，p是str的一份临时拷贝，所以当malloc在堆上开辟的空间起始地址放在p中（即p指向了这段空间时），不会影响str，str仍为NULL。
②当str为空时，strcpy想把"hello world"拷贝到str所指向空间时，程序崩溃，因为NULL指向的空间是不能直接访问的（还记得strcpy模拟实现的时候进去就要断言吗）。

:fish:2°内存泄漏

更可怕的是想释放都没办法释放，函数调用完，p随之销毁(即malloc开辟出来的空间的起始地址丢失），这段空间无法找到，无从释放。

:white_check_mark: 更正: 传址调用

void GetMemory(char** p) 
{
    *p = (char *)malloc(100);
}
void Test(void) 
{
    char *str = NULL;
    GetMemory(&str);
    strcpy(str, "hello world");
    printf(str);//运行结果？

    //释放
    free(str);
    str = NULL;
}

运行结果:
在这里插入图片描述
:heart:注:
这里大家可能有疑惑在printf(str);。

char* p = "hello world";
printf("hello world");
printf(p);//okay！

3.2 笔试题2

上代码思考:

#include<stdio.h>
#include<stdlib.h>

char* GetMemory(void) 
{
    char p[] = "hello world";
    return p;
}
void Test(void) 
{
    char *str = NULL;
    str = GetMemory();
    printf(str);//运行结果？
}
int main()
{
    Test();
    return 0;
}

运行结果 --- 打印随机值:cold_sweat:
在这里插入图片描述

:key:解析 --- 事实上，这都属于 返回栈空间地址引发的问题

在这里插入图片描述
像这样返回栈空间地址就是典型的造成野指针的原因之一。

与之相似的错误代码演示:

#include<stdio.h>

int* test()
{
    int n = 10;
    return &n;
}

int main()
{
    int* p = test();
    printf("%d\n", *p);
    return 0;
}

预测运行结果：可能打印随机值。

运行结果---虽然报了一个警报，但还是打印了10
在这里插入图片描述
这可能会让你震惊，这里打印10也并非巧合，如果还没调用其他函数，销毁的空间未被覆盖掉，确实可能访问到10.

我当然也可以让它不是10，这里随便打印一个"hehe":

int main()
{
    int* p = test();
    printf("hehe\n");
    printf("%d\n", *p);//运行结果？
    return 0;
}

再来运行，运行结果--- 随机值
在这里插入图片描述
解析---画图简述函数栈桢创建与销毁：

这些讨论，都是为了说明返回栈空间地址时的这种错误。

3.3 笔试题3

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

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

在这里插入图片描述

问题：内存泄漏！！

:white_check_mark:要记得释放空间：

free(str);
str = NULL;

3.4 笔试题4

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

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

有结果也不对，要明白编译器是不能查出所有错误的，不然要你程序猿干嘛。
在这里插入图片描述

:key:解析

在这里插入图片描述
因此，还是要记得free后，将str置空。

free(str);
str = NULL;

4. C/C++程序的内存开辟

在这里插入图片描述
C/C++程序内存分配的几个区域：

==栈区（stack）==：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限，因此会有栈溢出的情况。

栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

==堆区（heap）==：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS(操作系统)回收。分配方式类似于链表。

==数据段/静态区(static)==:存放全局变量、静态数据。程序结束后由系统释放。

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

有了这幅图，我们就可以更好的理解static关键字修饰局部变量的例子了。

实际上普通的局部变量是在栈区分配空间的， 栈区的特点是在上面创建的变量 出了作用域就销毁。
但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁，所以 生命周期变长。

下篇文章将介绍柔型数组。
未完待续

【C】动态内存函数@动态内存管理 —— malloc | free | calloc | realloc

1. 动态内存函数的介绍

1.1 malloc和free

1.1.1 malloc

1.1.2 搭配使用的free

1.2 calloc

1.3 realloc

2. 常见动态内存错误

2.1 对动态开辟的空间越界访问

2.2 对NULL指针解引用

2.3 对非动态开辟的内存用free释放

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

2.5 对同一块内存多次释放

2.6 动态开辟的内存忘记释放(内存泄漏)

3. 经典笔试题

3.1 笔试题1

3.2 笔试题2

3.3 笔试题3

3.4 笔试题4

4. C/C++程序的内存开辟

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【C】动态内存函数@动态内存管理 —— malloc | free | calloc | realloc

1. 动态内存函数的介绍

1.1 malloc和free

1.1.1 malloc

1.1.2 搭配使用的free

1.2 calloc

1.3 realloc

2. 常见动态内存错误

2.1 对动态开辟的空间越界访问

2.2 对NULL指针解引用

2.3 对非动态开辟的内存用free释放

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

2.5 对同一块内存多次释放

2.6 动态开辟的内存忘记释放(内存泄漏)

3. 经典笔试题

3.1 笔试题1

3.2 笔试题2

3.3 笔试题3

3.4 笔试题4

4. C/C++程序的内存开辟

热门文章

最新文章

相关电子书