C进阶-动态内存管理

已于 2023-10-17 20:31:00 修改
阅读量209 收藏 5
点赞数 8
分类专栏： c 文章标签： c语言 开发语言
于 2023-10-15 16:33:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61658398/article/details/133842043
版权

本章重点：

为什么存在动态内存分配？

动态内存函数的介绍  malloc  free  calloc  realloc

常见的动态内存错误

经典的笔试题

柔性数组

1.为什么存在动态内存分配

开辟空间的方式有两个特点：

1.    空间开辟大小是固定的。

2.    数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。 这时候就只能试试动态存开辟了。

2.动态内存函数的介绍

动态内存管理函数： malloc、free、realloc、calloc

2.1malloc函数：

void* malloc (size_t size);

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

如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

 

free函数： 

void free (void* ptr);

free函数用来释放动态开辟的内存

如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。如果参数 ptr 是NULL指针，则函数什么事都不做。

int main()
{
    //int arr[10];
    int* p = (int*)malloc(40);  // 使用malloc需要 #include <stdlib.h>

    if (p == NULL)
    {
        perror("malloc");
        return 1;
    }
    //开辟空间成功
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        printf("%d\n",*(p+i));
    }

    free(p);   // 把p所指的空间释放
    p = NULL;

    return 0;
}

 2.2 callo函数

void* calloc (size_t num, size_t size);

函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。 举个例子：

int main()
{
    //int* p  = (int*)calloc(INT64_MAX,sizeof(int)); //开辟失败
    int* p  = (int*)calloc(10,sizeof(int)); //开辟失败
    if (p == NULL)
    {
        perror("calloc");
        return 1;
    }

    //打印数据
    int i = 0;
    for (i = 0; i<10; i++)
    {
        printf("%d ",p[i]);
    }
    //释放
    free(p);
    p = NULL;

    return 0;
}

2.3 realloc

realloc函数的出现让动态内存管理更加灵活。
有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。 函数原型如下：

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

ptr 是要调整的内存地址

size 调整之后新大小
返回值为调整之后的内存起始位置。

这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间。 realloc在调整内存空间的是存在两种情况：

 

 

int main()
{
    int* p = (int*)malloc(40);
    if (p == NULL)
    {
        perror("malloc");
        return 1;
    }

    //初始化为1-10
    int i = 0;
    for (i = 0;i < 10;i++)
    {
        p[i] = i+1;
    }
    //增加一些空间
    int* ptr =  (int*)realloc(p,80);
    if (ptr != NULL)
    {
        p = ptr;
    }
    else
    {
        perror("realloc");
        return 1;
    }

    //打印数据
    for (i = 0; i< 20; i++)
    {
        printf("%d\n",p[i]);
    }
    //释放
    free(p);
    p = NULL;

    return 0;
}

3 常见的动态内存操作

3.1 对NULL指针的解引用操作

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

int main()
{
    test();


    return 0;
}

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

int main()
{
    int i = 0;
    int *p = (int*)malloc(40);
    if(p == NULL)
    {
        perror("malloc");
        return 1;
    }
    for (i = 0; i < 20; i++)
    {
        p[i] = i;  //越界访问
    }
    free(p);
    p = NULL;

    return 0;
}

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

int main()
{
    int a = 10;
    int* p = &a;
    printf("%d\n",*p);

    free(p);
    p = NULL;


    return 0;
}

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

int main()
{
    int i = 0;
    int *p = (int*)malloc(40);
    if(p == NULL)
    {
        perror("malloc");
        return 1;
    }
    for (i = 0; i < 5; i++)
    {
        *p = i;
        p++;
    }

    //释放
    free(p);
    p = NULL;


    return 0;
}

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

int main()
{
    int* p = (int*)malloc(40);
    if (p == NULL)
    {
        return 1;
    }
    //使用
    free(p);
    //p = NULL;

    free(p);
    return 0;
}

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

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

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

    return 0;
}

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

int main()
{
    Test();
    return 0;
}

 正确版：

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

int main()
{
    Test();
    return 0;
}

4.2 

char *GetMemory(void)
{
    //static char p[] = "hello world";
    char p[] = "hello world";
    return p;
}

void Test(void)
{
    char *str = NULL;
    str = GetMemory();  //野指针
    printf(str);
}

int main()
{
    Test();

    return 0;
}



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

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

    return 0;
}

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

int main()
{
    Test();

    return 0;
}

缺少释放内存！

4.4

void Test(void)
{
    char *str = (char *)malloc(100);
    strcpy(str, "hello");
    free(str);  //释放完后没有把str置为空指针，会非法访问
    //str = NULL;
    if (str != NULL)
    {
        strcpy(str, "world");
        printf(str);
    }
}

int main()
{
    Test();


    return 0;
}

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

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

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

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

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

 

6. 柔性数组

也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。 C99 中，结构中的最 后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

 

struct s 
{
    int n;
    int arr[0];  //柔性数组
};

int main()
{

    return 0;
}

6.1 柔性数组的特点：

结构中的柔性数组成员前面必须至少一个其他成员。

sizeof 返回的这种结构大小不包括柔性数组的内存。

包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应

柔性数组的预期大小。

 

struct S 
{
    int n;
    int arr[0];  //柔性数组
};

int main()
{
    printf("%d\n",sizeof(struct S));  //4
    return 0;
}

6.2 柔性数组的使用

struct S 
{
    int n;
    int arr[0];  //柔性数组
};

int main()
{
    //printf("%d\n",sizeof(struct S));  //4

    struct S* ps = (struct S*)malloc(sizeof(struct S)+40);
    if (ps == NULL)
    {
        perror("malloc");
        return 1;
    }
    ps->n = 100;
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        ps->arr[i] = i + 1;
    }

    //空间不够，需要增容
    struct S* ptr = (struct S*)realloc(ps,sizeof(struct S)+60);
    if (ptr == NULL)
    {
        perror("realloc");
        return 1;
    }
    ps = ptr;
    ps->n = 15;
    for (i = 0; i < 15; i++)
    {
        printf("%d\n",ps->arr[i]);
    }

    //释放
    free(ps);
    ps = NULL;

    return 0;
}

6.3 柔性数组的优势

// struct S 
// {
//     int n;
//     int arr[0];  //柔性数组
// };

// int main()
// {
//     //printf("%d\n",sizeof(struct S));  //4

//     struct S* ps = (struct S*)malloc(sizeof(struct S)+40);
//     if (ps == NULL)
//     {
//         perror("malloc");
//         return 1;
//     }
//     ps->n = 100;
//     int i = 0;
//     for (i = 0; i < 10; i++)
//     {
//         ps->arr[i] = i + 1;
//     }

//     //空间不够，需要增容
//     struct S* ptr = (struct S*)realloc(ps,sizeof(struct S)+60);
//     if (ptr == NULL)
//     {
//         perror("realloc");
//         return 1;
//     }
//     ps = ptr;
//     ps->n = 15;
//     for (i = 0; i < 15; i++)
//     {
//         printf("%d\n",ps->arr[i]);
//     }

//     //释放
//     free(ps);
//     ps = NULL;

//     return 0;
// }

struct S
{
    int n;
    int* arr;
};
int main()
{
    struct S* ps = (struct S*)malloc(sizeof(struct S));
    if (ps == NULL)
    {
        perror("malloc->arr");
        return 1;
    }
    ps->n = 100;
    ps->arr = (int*)malloc(40);// 1 2 3 4 5 6 7 8 9 0
    if (ps->arr == NULL)
    {
        perror("malloc-arr");
        return 1;
    }
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        ps->arr[i] = i+1;
    }

    //调整
    int* ptr = (int*)realloc(ps->arr,60);
    if (ptr != NULL)
    {
        ps->arr = ptr;

    }
    else
    {
        perror("realloc");
        return 1;
    }
    //打印
    for (i = 0; i < 15; i++)
    {
        printf("%d\n",ps->arr[i]);
    }

    //释放
    free(ps->arr);
    ps->arr = NULL;


    free(ps);
    ps = NULL;

    return 0;
}

小凡喜编程
关注
专栏目录
C语言进阶---动态内存管理.md
04-03
动态内存空间开辟的详细讲解
C语言进阶-深度剖析.zip
10-15
书中会详细讲解指针的类型、运算符、指针与数组的关系，以及指针在函数参数传递和动态内存管理中的应用。 其次，文件操作是C语言中的一个重要部分，本书会介绍如何打开、读写和关闭文件，以及错误处理机制。读者还...
C语言进阶-动态内存管理
m0_56900257的博客
03-08 926
这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。如果开辟成功，则返回一个指向开辟好空间的指针。如果开辟失败，则返回一个NULL指针,因此malloc的返回值一定要做检查。返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，具体在使用的时候来决定。如果参数 size 为0，malloc的行为标准是未定义的，取决于编译器。int main()//动态开辟return 1;//使用i < 10;i++)//即使没有free。
C语言进阶-动态内存管理/柔性数组
~
10-01 1381
动态内存管理的使用即注意事项有关于动态内存管理的寄到笔试题讲解柔性数组的使用为什么存在动态内存分配一般的开辟空间方式：//在栈空间上开辟四个字节//在栈空间上开辟10个字节的连续空间特点：空间开辟大小是固定的（数组申明必须指定数组的长度，它所需要的内存在编译时分配）但有时候我们需要的空间大小在程序运行的时候才能知道， 那数组的编译时开辟空间的方式就不能满足了，由此动态内存开辟就来了动态内存函数的介绍。
c语言进阶-动态内存管理
myz1016的博客
07-07 345
返回值是无类型的指针，指向分配的内存的首地址。申请失败会返回空指针。Malloc 内存申请函数。
C语言进阶--动态内存管理
weixin_36194037的博客
06-29 1136
C语言进阶--动态内存管理
C语言进阶---动态内存管理
weixin_75128035的博客
09-27 1479
中秋佳节倍思亲 千里同赏十五月 中 秋 节 快 乐 ʚ🥮ɞ Ɱօօղ ↻ąҟҽ 愿你千山暮雪海棠依旧🌟🌖🥮 不为岁月惊扰平贴忧愁 ☁ᕱ⑅ᕱ🔅
C语言突破进阶-动态内存管理
Allen9012的博客
01-26 664
C语言突破进阶-动态内存管理1. 动态内存分配快速入门1.1 栈上开辟特点1.2 动态开辟位置2. 动态内存函数2.1 `malloc`2.1.1 malloc快速入门2.2 `free`2.2.1 free快速入门2.3 `calloc`2.3.1 calloc 快速入门2.4 `realloc`2.4.1 realloc快速入门2.4.2 realloc 调整空间的两种情况:herb: 情况一：原有空间之后有足够大的空间:herb: 情况2：原有空间之后没有足够大的空间2.4.3 realloc注意事项
C语言进阶--动态内存管理（一）
Liu_20236666的博客
10-01 253
C语言进阶--动态内存管理（一）
进阶--动态内存管理
GRL8013的博客
03-03 154
有时候我们需要的空间大小在程序运行的时候，数组的编译时开辟空间的方式不能满足。这个时候只能尝试动态内存开辟了。c语言提供了另外一个函数free，专门是用来做动态内存释放和回收发，函数原型如下：
C语言进阶 -- 动态内存管理
weixin_72481085的博客
07-15 431
C语言进阶 -- 动态内存管理
进阶C语言-动态内存管理
qq_73121173的博客
02-14 918
关于动态内存管理的知识点！
C语言进阶－第2讲C语言复习共25页.pdf.zip
11-22
2. **内存管理**：包括动态内存分配（`malloc`, `calloc`, `realloc`, `free`）和栈与堆的理解，以及内存泄漏的避免。 3. **预处理器宏和头文件**：学习如何使用`#define`定义宏，以及如何组织和包含头文件来管理...
杨辉三角-C语言
m0_56065966的博客
09-26 366
轻松用C语言输出杨辉三角
第十四届蓝桥杯真题Java c组A.求和(持续更新)
音符犹如代码的博客
09-28 333
我们还可以使用数学公式来优化这个过程。
C 语言中 & 符号的两种用途
m0_46398975的博客
09-23 412
C 语言中 `&` 符号的两种用途
第十四届蓝桥杯真题Python c组F.棋盘(持续更新)
最新发布
音符犹如代码的博客
09-28 417
小蓝拥有 n × n 大小的棋盘，一开始棋盘上全都是白子。小蓝进行了m次操作，每次操作会将棋盘上某个范围内的所有棋子的颜色取反(也就是白色棋子变为黑色，黑色棋子变为白色)。请输出所有操作做完后棋盘上每个棋子的颜色。接下来m行每行包含四个整数 X1，Y1，X2，Y2，相邻整数之间使用一个空格分隔，表示将在X1至X2行和Y1至Y2列中的棋子颜色取反。输出n行，每行n个0或1表示该位置棋子的颜色。如果是白色则输出0，否则输出1。输入的第一行包含两个整数n，m，用一个空格分隔，表示棋盘大小与操作数。
凌明老师讲解：嵌入式C语言进阶-存储器与指针解析
"凌明老师在东南大学集成电路中心的嵌入式高级C语言进阶课程的第四讲，主要探讨了存储器与指针的相关概念，包括指针的基础知识、存储器分类、动态内存分配以及相关的编程实践。" 本文将详细阐述存储器与指针在...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值