C语言动态内存管理

已于 2024-01-17 15:58:54 修改
阅读量855 收藏 18
点赞数 27
分类专栏： C语言基础知识 文章标签： c语言
于 2024-01-08 19:56:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73281594/article/details/135465136
版权
本文详细介绍了C/C++中的动态内存管理，包括malloc,free,calloc,realloc函数的用法，内存区域划分（栈、堆）以及常见错误，如NULL指针、越界访问、内存泄漏和柔性数组的使用及其优点。
摘要由CSDN通过智能技术生成

目录

C语言动态内存管理

动态内存管理的优点

C/C++中程序内存区域划分

malloc函数与free函数

malloc函数

free函数

calloc函数与realloc函数

calloc函数

realloc函数

常见的动态内存管理的错误

对NULL指针的解引用操作

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

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

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

对同一块动态内存多次释放

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

柔性数组

柔性数组的特点

柔性数组的使用

柔性数组的优点

C语言动态内存管理

动态内存管理的优点

变量和数组创建的空间固定，有时候需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足动态内存管理，而动态内存管理可以灵活地申请和释放空间

C/C++中程序内存区域划分

  • 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等
  • 堆区（heap）：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。分配方式类似于链表
  • 数据段（静态区）：（static）存放全局变量、静态数据，程序结束后由系统释放
  • 代码段：存放函数体（类成员函数和全局函数）的二进制代码
int globalVariable = 0;
static int staticGlobalVariable = 0;

void test()
{
    static int staticVariable = 0;
    int localVariable = 0;
    int num1[10] = { 1,2,3,4 };
    char char2[] = "abcd";
    char* pChar3 = "abcd";
    int* ptr1 = (int*)malloc(4 * sizeof(int));
    int* ptr2 = (int*)calloc(4, sizeof(int));
    int* ptr3 = (int*)realloc(ptr2, 4 * sizeof(int));
    
    free(ptr1);
    free(ptr3);
}

上述代码中对应的内容所在空间如下图：

malloc函数与free函数

📌

使用malloc函数和free函数需要包含头文件stdlib.h

malloc函数

函数作用：向内存申请一块连续可用的空间，并返回指向这块空间的指针

函数原型
void* malloc (size_t size);

参数说明
参数为size_t类型的变量，表示需要开辟的空间的大小，注意size = 数据类型个数*sizeof(数据类型)

返回类型
函数返回void*指针，该指针指向成功开辟的空间的地址
  • 如果开辟成功，则返回⼀个指向开辟好空间的指针。
  • 如果开辟失败，则返回⼀个 NULL 指针，因此malloc的返回值⼀定要做检查
  • 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者来决定
  • 如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器，注意malloc(0)是允许的，也会返回一个指针，只是没有空间所以不可使用而已
  • malloc函数开辟的空间没有初始值

代码实例

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int main()
{
    //固定开辟个数
    int* p = (int*)malloc(10 * sizeof(int));//使用malloc开辟10个int类型大小的空间
    assert(p);//使用断言对p是否是空指针进行判断，如果p为空指针则表达式为假，终止程序继续运行
    //使用变量决定开辟个数
    int num = 0;
    scanf("%d", &num);
    int* p1 = (int*)malloc(num * sizeof(int));//使用malloc开辟num个int类型大小的空间
    assert(p1);

    for (int i = 0; i < 10; i++)
    {
        printf("%x ", p[i]);//malloc函数开辟的空间没有赋初始值
    }

    putchar('\n');

    for (int i = 0; i < 10; i++)//访问开辟的10个int类型大小的空间
    {
        p[i] = i;
        printf("%d ", *(p + i));
    }

    putchar('\n');

    for (int i = 0; i < num; i++)//访问开辟的num个int类型大小的空间
    {
        p1[i] = i;
        printf("%d ", *(p1 + i));
    }

    //使用free函数将动态开辟的内存释放
    free(p);
    p = NULL;
    free(p1);
    p1 = NULL;

    return 0;
}
输入：
15
输出结果：
cdcdcdcd cdcdcdcd cdcdcdcd cdcdcdcd cdcdcdcd cdcdcdcd cdcdcdcd cdcdcdcd cdcdcdcd cdcdcdcd
0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

free函数

函数作用：用来进行动态内存的释放和回收

函数原型
void free (void* ptr);

参数说明
参数为一个void*类型的指针，该指针指向动态内存开辟函数返回的地址
  • 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的
  • 如果参数 ptr 是NULL指针，则函数不处理任何事务

📌

注意free函数不会将接收动态内存开辟函数成功开辟空间后返回的地址的指针置为空，仅仅只是将开辟的空间释放

代码实例

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int main()
{
    //固定开辟个数
    int* p = (int*)malloc(10 * sizeof(int));//使用malloc开辟10个int类型大小的空间
    assert(p);//使用断言对p是否是空指针进行判断，如果p为空指针则表达式为假，终止程序继续运行
    //使用变量决定开辟个数
    int num = 0;
    scanf("%d", &num);
    int* p1 = (int*)malloc(num * sizeof(int));//使用malloc开辟num个int类型大小的空间
    assert(p1);

    //使用free函数将动态开辟的内存释放
    free(p);
    p = NULL;//一定要将未使用的指针置为空，避免野指针
    free(p1);
    p1 = NULL;

    return 0;
}

calloc函数与realloc函数

📌

使用calloc函数和realloc函数需要包含头文件stdlib.h

calloc函数

函数作用：向内存申请一块连续可用的空间，并返回指向这块空间的指针，与malloc不同的是，calloc函数会为开辟的空间赋初始值为0

函数原型
void* calloc (size_t num, size_t size);

参数说明
第一个参数是size_t类型的变量，表示需要开辟的内存块的大小
第二个参数是size_t类型的变量，表示每个空间占用的大小，即sizeof(数据类型)，单位为字节

返回类型
函数返回一个void*类型的指针，该指针指向成功开辟后的空间的地址

代码实例

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int main()
{
    //固定开辟个数
    int* p = (int*)calloc(10, sizeof(int));
    assert(p);//使用断言对p是否是空指针进行判断
    //使用变量决定开辟个数
    int num = 0;
    scanf("%d", &num);
    int* p1 = (int*)calloc(num, sizeof(int));
    
    for (int i = 0; i < 10; i++)
    {
        printf("%x ", p[i]);//calloc函数开辟的空间有初始值为0
    }

    putchar('\n');

    for (int i = 0; i < 10; i++)//访问开辟的10个int类型大小的空间
    {
        p[i] = i;
        printf("%d ", *(p + i));
    }

    putchar('\n');

    for (int i = 0; i < num; i++)//访问开辟的num个int类型大小的空间
    {
        p1[i] = i;
        printf("%d ", *(p1 + i));
    }

    //使用free函数将动态开辟的内存释放
    free(p);
    p = NULL;
    free(p1);
    p1 = NULL;

    return 0;
}
输入：
15
输出结果：
0 0 0 0 0 0 0 0 0 0
0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

realloc函数

函数作用：对动态开辟内存大小的调整

函数原型
void* realloc (void* ptr, size_t size);

参数说明
第一个参数为void*类型的指针，该指针指向动态内存函数成功开辟的空间的原始地址
第二个参数为size_t类型的变量，表示需要改变的空间的大小，注意size = 数据类型个数*sizeof(数据类型)

返回类型
函数返回一个void*类型的指针，该指针指向成功开辟的空间的地址
  • 该函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间
  • 尽量不要使用已经指向有malloc或者calloc函数开辟的空间的地址的指针作为接收realloc函数开辟空间的地址的指针，如果realloc开辟失败将会导致原来由malloc或者calloc函数开辟的空间丢失找不到的情况
int* p = (int*)malloc(10 * sizeof(int));
assert(p);

p = (int*)realloc(p, 10 * sizeof(int));//不要这样做，否则可能导致malloc开辟的空间丢失并且无法free进而导致内存泄漏

📌

使用realloc函数时不需要对指向原来的malloc函数和calloc函数开辟的空间的指针进行释放操作，realloc会对原来malloc函数和calloc函数开辟的空间进行管理

#define _CRT_SECURE_NO_WARNINGS 1

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

int main()
{
    int* p = (int*)calloc(10, sizeof(int));
    assert(p);

    int* p1 = (int*)realloc(p, 10 * sizeof(int));
    assert(p1);
    
    //使用realloc后，不需要再对malloc或者calloc开辟的空间进行释放，因为已经由realloc来管理，只需要将原来的指针进行置为空，或者直接用临时指针中的地址覆盖
    //free(p);
    p = NULL;//可以不需要此步
    p = p1;
    p1 = NULL;

    for (int i = 0; i < 10; i++)
    {
        p[i] = i;
        printf("%d ", p[i]);
    }

    free(p);
    p = NULL;

    return 0;
}
输出结果：
0 1 2 3 4 5 6 7 8 9
  • realloc在调整内存空间的是存在两种情况：
    • 情况1：原有空间之后有足够大的空间
    • 情况2：原有空间之后没有足够大的空间

对于情况1：

realloc函数要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化

对于情况2：

realloc函数在堆空间上另找一个合适大小的连续空间来使用，函数返回的是一个新的内存地址

代码实例

#define _CRT_SECURE_NO_WARNINGS 1

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

int main()
{
#define _CRT_SECURE_NO_WARNINGS 1

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

int main()
{
    //情况1，原空间后有足够大的空间
    int* p = (int*)calloc(10, sizeof(int));
    assert(p);
    printf("%p\n", p);

    int* p1 = (int*)realloc(p, 10 * sizeof(int));
    assert(p1);
    printf("%p\n", p1);
    
    p = p1;

    for (int i = 0; i < 10; i++)
    {
        p[i] = i;
        printf("%d ", p[i]);
    }
    putchar('\n');

    //情况2，原空间后无足够大的空间
    int* p2 = (int*)calloc(10, sizeof(int));
    assert(p2);
    printf("%p\n", p2);

    int* p3 = (int*)realloc(p2, 100 * sizeof(int));
    assert(p3);
    printf("%p\n", p3);

    p2 = p3;

    for (int i = 0; i < 10; i++)
    {
        p2[i] = i;
        printf("%d ", p2[i]);
    }

    //使用free函数将动态开辟的内存释放
    free(p);
    p = NULL;
    p1 = NULL;//p1指向的空间已由p接管，故free只需要对p进行操作，p1直接置为空即可
    free(p2);
    p2 = NULL;
    p3 = NULL;//p3指向的空间已由p接管，故free只需要对p2进行操作，p3直接置为空即可

    return 0;
}
输出结果：
000001B3132AA500
000001B3132AA500
0 1 2 3 4 5 6 7 8 9
000001B3132B3150
000001B3132B3600
0 1 2 3 4 5 6 7 8 9

📌

当realloc函数的第一个参数为空指针NULL时，实现的效果与malloc函数相同

#define _CRT_SECURE_NO_WARNINGS 1

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

int main()
{
    int* p = (int*)malloc(10 * sizeof(int));
    assert(p);
    for (int i = 0; i < 10; i++)
    {
        p[i] = i;
        printf("%d ", p[i]);
    }

    putchar('\n');

    int* p1 = (int*)realloc(NULL, 10 * sizeof(int));
    assert(p1);
    for (int i = 0; i < 10; i++)
    {
        p1[i] = i;
        printf("%d ", p1[i]);
    }

    free(p);
    p = NULL;
    free(p1);
    p1 = NULL;

    return 0;
}
输出结果：
0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9

常见的动态内存管理的错误

对NULL指针的解引用操作

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

📌

无法保证malloc函数一定能成功开辟空间，所以在对p指针解引用操作之前一定要先判断是否是空指针

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

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

📌

上述代码中的malloc函数只开辟了10个空间，而在for循环中循环执行了11次，对malloc开辟的空间进行了越界访问

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

void test()1
{
    int a = 10;
    int *p = &a;
    free(p);
}

📌

p指向的空间是由变量创建开辟的空间，而不是由动态内存管理函数开辟的空间，不可以用free进行释放

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

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

📌

p++使得p指针不再指向动态内存的起始位置，此时进行free操作只对一部分空间进行了释放

对同一块动态内存多次释放

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

📌

使用free函数对p指向的空间进行了两次释放，但是因为第一个free函数调用就已经释放了malloc开辟的空间，此时不可以使用free对p指向的空间进行释放

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

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

📌

动态内存管理函数开辟的空间在内存的堆空间上，故如果不对该空间进行手动释放，只能等到程序终止后才会释放，若程序运行时间太长，将会导致内存泄露，故动态内存管理函数开辟的内存空间一定要及时释放，防止内存泄漏

柔性数组

在C语言C99标准中，结构体中的最后一个元素允许是未知大小的数组，这就叫做柔性数组成员变量

typedef struct st_type
{
    int i;
    int a[0];//柔性数组成员 
    //int a[];//或者不写0
}type_a;

柔性数组的特点

  • 结构中的柔性数组成员前面必须有至少一个其他成员
  • sizeof返回的这种结构大小不包括柔性数组的内存
  • 包含柔性数组成员的结构用malloc函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小
typedef struct st_type
{
    int i;
    int a[0];//柔性数组成员 
}type_a;

int main()
{
    printf("%d\n", sizeof(type_a));//输出的是int类型的大小，即4
    return 0;
}
输出结果：
4

柔性数组的使用

#define _CRT_SECURE_NO_WARNINGS 1

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

struct st_type
{
    int i;
    int a[0];
};

int main()
{
    struct st_type* p = (struct st_type*)malloc(sizeof(struct st_type) + 10 * sizeof(int));//计算出结构体的大小后再加上柔性数组需要的空间，确保开辟的空间适应柔性数组的预期大小
                                                                                    //此处的10 * sizeof(int)即为柔性数组的空间大小
    assert(p);
    p->i = 100;//为结构体成员变量赋值

    for (int i = 0; i < 10; i++)//访问柔性数组
    {
        p->a[i] = i;
        printf("%d ", p->a[i]);
    }
    //释放结构体指针
    free(p);
    p = NULL;

    return 0;
}
输出结果：
0 1 2 3 4 5 6 7 8 9

柔性数组的优点

对比结构体中的指针成员变量指向malloc开辟的空间

//代码2 
#define _CRT_SECURE_NO_WARNINGS 1

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

struct st_type
{
    int i;
    int* p_a;
};

int main()
{
    struct st_type* p = (struct st_type*)malloc(sizeof(struct st_type));
    assert(p);
    
    p->i = 10;
    p->p_a = (int*)malloc(p->i * sizeof(int));
    assert(p->p_a);

    for (int i = 0; i < 10; i++)
    {
        p->p_a[i] = i;//通过结构体的指针成员变量访问malloc开辟的空间
    }

    //释放空间 
    //既需要将结构体类型的指针指向的malloc开辟的空间释放
    //还需要释放结构体中的指针成员变量指向的malloc开辟的空间
    //并且需要优先释放结构体中的指针成员变量指向的malloc开辟的空间
    free(p->p_a);
    p->p_a = NULL;
    free(p);
    p = NULL;

    return 0;
}
  • 第一个好处是：方便内存释放（不会遗漏需要释放的空间）

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

  • 第二个好处是：有利于访问速度

连续的内存有益于提高访问速度，也在一定程度上有益于减少内存碎片

怡晗★
关注
专栏目录
C语言——动态内存
保护小周ღ的博客
04-14 3073
大家好！我是保护小周，本期为大家带来超详细的C语言——动态内存管理，论动态内存在C++/C中的重要性，学好动态内存约等于看穿了C语言~确定不来看看嘛 ~ 1.为什么存在动态内存 2.动态内存函数的介绍 3.常见的动态内存错误 4.经典笔试题 5.柔性数组 快来跟我一起学习吧！ ......
C语言中的动态内存管理
SPMAX的博客
01-30 1671
前言在了解动态内存管理之前，我们要先了解关于c语言的内存中的栈区、堆区和静态区：栈区主要存储形式参数（也就是我们调用函数的时候一般会将我们定义的实参传入函数后所形成的参数），以及局部变量（比如说就是我们在main函数中定义的int A=10;等等的变量）。在栈区创立的变量在程序运行完后会自动回收，不需要我们去进行回收操作，而堆区是我们可以在堆区内存充裕时按照自己所需要的字节大小去主动申请空间的地方，我们称之为堆区，也就是我们下面主要要讲到的动态内存管理，相比于栈区更具有可操作性，需要自己去回收。最后一个时静
【C++】C/C++内存管理(超详细解析，小白必看系列）
最新发布
m0_73494049的博客
08-29 1191
本文详述了C/C++中的内存分布与管理机制，包括代码段、数据段、堆和栈的作用及特点。对比分析了C语言中的动态内存管理函数（malloc、calloc、realloc、free）与C++中new/delete操作符的使用场景与差异。深入探讨了C++中operator new与operator delete函数的内部实现，以及它们如何支持自定义类型内存管理。最后，介绍了定位new表达式的概念及其在特定内存管理策略中的应用。
C语言之动态内存管理（动态内存函数）
Sheena997的博客
12-26 1648
我们开辟空间的时候，空间的大小是固定的。 在数组申明的函数，必须要指定数组的长度，它所需要的内存在编译时分配的。 但是如果想要开辟不固定大小的空间，该怎么办？ 解决方式就是动态进行内存的分配，即在堆上开辟空间。 本篇博客将介绍如何动态开辟空间。 一、动态内存函数 C语言中与动态内存管理相关的函数，主要有四个malloc、free、calloc和realloc。 1.malloc void...
动态内存管理（堆区）
一个计算机爱好者学习历程
11-05 539
为什么存在动态内存管理 1.可以申请大块内存，进行较为大型的应用 2.可以在程序运行期间进行申请，可以更灵活的使用内存空间。 （申请空间用malloc()函数，必须是程序运行起来才能调用，编译的过程早就过了） 如何进行空间管理？ 通过malloc函数申请空间和使用，用free函数释放空间 常见细节： 1.整体申请，整体释放。 2.如果申请内存不归还，会造成内存泄漏。 内存泄漏：一种严重的问题，会造成可用内存越来越少。 进程退出了，内存泄漏问题就不在...
C语言动态内存管理笔记
03-09
个人学习总结
C语言实现内存管理
03-21
在编程世界中，C语言因其低级特性而被广泛用于系统级编程，其中包括内存管理。内存管理是程序设计中的核心部分，它涉及到如何有效地分配、使用和释放内存资源。本主题将深入探讨如何使用C语言来实现内存管理的关键...
C语言的内存管理机制
02-24
本文是作者在学习C语言内存管理的过程中做的一个总结。全局变量（外部变量）：出现在代码块{}之外的变量就是全局变量。局部变量（自动变量）：一般情况下，代码块{}内部定义的变量就是自动变量，也可使用auto显示...
C语言——动态内存管理
Stewie Lee的博客
04-26 1040
静态分配的内存大小在编译时就固定了，不论是否使用都会占用这部分资源。动态内存管理可以根据实际需要来分配内存，这有助于避免浪费和更有效地利用有限的内存资源。许多复杂的数据结构，如树、图和各种链式结构，通常需要在运行时动态地创建和销毁节点，这也需要动态内存管理。
C语言：动态内存管理
carl_2018的博客
05-21 387
为什么使用动态内存分配 当声明数组时，必须用一个编译时常量指定数组的长度。但是，数组的长度常常在运行时才知道，它所需要的内存空间取决于输入数据，数组的编译时开辟空间的方式就不能满足了。 动态内存函数的介绍 malloc void* malloc (size_t size); 这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。 如果开辟成功，则返回一个指向开辟好空间的指针。 如果...
[C语言]动态内存管理
weixin_43717520的博客
04-23 250
malloc
动态内存管理--malloc/calloc/realloc/free的用法
weijie_win的博客
03-26 208
1.动态内存分配 动态内存分配在堆上,栈区的会自动销毁和创建 为什么存在动态内存分配? 我们已经掌握的内存开辟方式有： int val = 20;//在栈空间上开辟四个字节 char arr[10] = {0};//在栈空间上开辟10个字节的连续空间 但是上述的开辟空间的方式有两个特点： 空间开辟大小是固定的。 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。 但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

怡晗★

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值