C语言——动态内存管理

最新推荐文章于 2024-08-20 12:46:36 发布
最新推荐文章于 2024-08-20 12:46:36 发布
阅读量1k 收藏 10
点赞数 11
分类专栏： C语言 文章标签： c语言 iphone 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/plj521/article/details/132253522
版权
本文详细解析了动态内存分配的原理、malloc、calloc、realloc和free函数的用法，列举了常见的内存错误类型及其解决方案，以及柔性数组的概念和优势。
摘要由CSDN通过智能技术生成

动态内存管理详解

前言：

我们一般开辟内存是直接开辟空间，开辟了空间就不会改变了，为了更节约空间，避免浪费空间，我们可以动态的开辟空间。这样，空间用完了，我们可以扩充空间。

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

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

int vai=10； / /在栈空间上开辟四个字节。
int arr[10]={0}; / /在栈空间上开辟40个字节的连续空间。
特点：

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

二、动态内存函数

关于动态内存函数的知识，可以参考我的另一篇文章动态内存函数详解

2.1malloc函数

void* malloc（size_t size）;

malloc函数向内存申请一块连续可用的空间，返回指向这个空间的指针。
malloc函数申请到空间后直接返回这块空间的起始地址，不会初始化空间的内容。
malloc申请的空间，当程序退出时，还给操作系统，当程序不退出，动态申请的内存，不会主动释放，需要用free函数来释放

2.2calloc函数

void* calloc(size_t num , size_t size) ;

calloc函数也可以申请动态内存空间。并且给空间初始化为0。

2.3realloc函数

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

realloc函数可以申请动态内存空间，使动态内存空间管理更灵活。

2.4free函数

void* free (void* ptr ) ;

free函数只能释放动态开辟的内存。

三、常见的动态内存错误

3.1 对NULL指针解引用操作

可能运行成功

#include <stdio.h>
#include <stdlib.h>
void test()
{
    int* p = (int*)malloc(10 * sizeof(int));
    *p = 20;//如果p的值是NULL就会有问题
    free(p);
}
int main()
{
    test();
    return 0;
}

解决方法：需要对空指针进行判定（空指针不能被赋值，就是p为空不能解引用）

#include <stdio.h>
#include <stdlib.h>
void test()
{
    int* p = (int*)malloc(10 * sizeof(int));
    if (p == NULL)
    {
        perror("malloc");
        return;
    }
    *p = 20;//如果p的值是NULL就会有问题
    free(p);
}
int main()
{
    test();
    return 0;
}

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

越界访问系统会崩溃

#include <stdio.h>
#include <stdlib.h>
void test()
{
    int i = 0;
    int* p = (int*)malloc(10 * sizeof(int));
    if (p == NULL)
    {
        perror("malloc");
        return;
    }
    for (i = 0; i <= 10; i++)
    {
        *(p + i) = i + 1;//当i=10时，越界访问
    }
   
    free(p);
}
int main()
{
    test();
    return 0;
}

解决：因为要访问的空间存在越界问题，那么我们就让它不越界访问

#include <stdio.h>
#include <stdlib.h>
void test()
{
    int i = 0;
    int* p = (int*)malloc(10 * sizeof(int));
    if (p == NULL)
    {
        perror("malloc");
        return;
    }
    for (i = 0; i < 10; i++)//改为i < 10
    {
        *(p + i) = i + 1;
    }
    free(p);
}
int main()
{
    test();
    return 0;
}

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

程序崩溃

#include <stdio.h>
#include <stdlib.h>
void test()
{
    int a = 10;
    int* p = &a;
    //释放非动态开辟内存空间有问题
    free(p);//不行，运行程序系统崩溃
}
int main()
{
    test();
    return 0;
}

解决方法：非动态开辟的内存不要用free函数释放

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

系统崩溃

#include <stdio.h>
#include <stdlib.h>
void test()
{
    int* p = (int*)malloc(10 * sizeof(int));
    if (p == NULL)
    {
        perror("malloc");
        return;
    }
    int i = 0;
    for (i = 0; i < 5; i++)
    {
        *p = i;
        p++;
    }
    //释放
    free(p);//p不在指向动态内存的起始位置
    p = NULL;
}
int main()
{
    test();
    return 0;
}

解决问题：动态开辟内存起始位置不能乱使用，释放的时候要从起始位置全部释放（开辟的一块连续的空间）

p++；（这里p不是指向开辟空间的起始位置，释放的是后面的一部分，前面没有释放，程序崩溃了。）

3.5 对同一块内存多次释放

程序崩溃了，不允许这么操作。

#include <stdio.h>
#include <stdlib.h>
void test()
{
    int* p = (int*)malloc(10 * sizeof(int));
    if (p == NULL)
    {
        perror("malloc");
        return;
    }
    //使用
    
    //释放
    free(p);
    //释放
    free(p);//重复释放，程序就崩了
}
int main()
{
    test();
    return 0;
}

解决方法：第一次释放结束，把p置NULL，下一次释放，释放空指针，啥事都不干。

#include <stdio.h>
#include <stdlib.h>
void test()
{
    int* p = (int*)malloc(10 * sizeof(int));
    if (p == NULL)
    {
        perror("malloc");
        return;
    }
    //使用
    
    //释放
    free(p);
    //释放结束，把p置空
    p = NULL;
    //释放
    free(p);
}
int main()
{
    test();
    return 0;
}

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

找不到p，没有释放技术内存泄漏

#include <stdio.h>
#include <stdlib.h>
void test()
{
    int* p = (int*)malloc(100);
    if (p == NULL)
    {
        perror("malloc");
        return;
    }
    *p = 20;
}
int main()
{
    test();
    //回来之后，p被销毁
    while (1);
    return 0;
}
  1. 把100个字节空间的起始地址赋值给p。
  2. p是函数里的局部变量。
  3. 出了这个函数p被销毁，找不到这100个字节的空间了，但是这100个字节的空间还在。

解决方法：只有两种方式可以销毁。

  • free函数释放。
  • 程序结束（退出）

注意：
动态申请的内存空间不会因为出了作用域就自动销毁，也·不会把内存还给操作系统。

四、几个经典的例子

题目1:
存在两个问题

#include <stdio.h>
#include <stdlib.h>
void Getmemory(char* p)
{
    p = (char*)malloc(100);//没有释放空间，存在内存泄漏的问题
}
void test()
{
    char* str = NULL;
    Getmemory(str);
    strcpy(str, "hello world");//不能对空指针进行解引用操作，程序会崩溃。
    printf(str);
}
int main()
{
    test();
    return 0;
}

题目2：
存在一个问题

#include <stdio.h>
#include <string.h>
char* Getmemory()
{
    char p[] = "hello world";//函数结束，内存释放，空间还给操作系统。
}
void test(void)
{
    char* str = NULL;
    str=Getmemory();//记住了地址，却找不到数据（这是个野指针，它非法访问）
    strcpy(str, "hello world");
    printf(str);
}
int main()
{
    test();
    return 0;
}

题目3：
存在一个问题

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void Getmemory(char** p, int num)
{
    *p = (char*)malloc(num);
}
void test(void)
{
    char* str = NULL;
     Getmemory(&str,100);
    strcpy(str, "hello world");
    printf(str);
    //内存泄漏
    //free(str);
    //str=NULL;
}
int main()
{
    test();
    return 0;
}

题目4：
存在一个问题

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

void test(void)
{
    char* str =(char*) malloc(100);
    strcpy(str, "hello");
    free(str);//内存被释放，str成为野指针。
    if (str != NULL)//肯定成立
    {
        strcpy(str, "world");//非法访问
        printf(str);
    }
    printf(str);
}
int main()
{
    test();
    return 0;
}

五、c/c++程序的内存分配

初步了解c/c++中内存区域的划分：
在这里插入图片描述
1.栈区(stack) ：在执行函数时， 函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、 函数参数、返回数据、返回地址等。
2.堆区(heap) ：一般由程序员分配释放， 若程序员不释放， 程序结束时可能由OS回收，分配方式类似于链表，
3.数据段(静态区) (static)： 存放全局变量，静态数据。 程序结束后由系统释放。
4.代码段：存放函数体(类成员函数和全局函数)的二进制代码。
注意：
实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。但是被static修饰的变量存放在数据段(静态区)，数据段的特点是在上面创建的变量，直到程序结束才销毁。
所以static修饰的变量生命周期变长了。

六、柔性数组

结构体中，最后一个成员是数组或者是指针，他们是有区别的。
c99中，结构体的最后一个成员可以是未知大小的数组，这叫柔性数组的成员。
结构体：

typedef struct st
{
    int i;
    int arr[];  
}ts;

6.1柔型数组的特点

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

ts* ps = (ts*)malloc(sizeof(ts) + 40);

6.2 柔性数组的使用

int main()
{
int i = 0;
ts* p = (ts*)malloc(sizeof(ts) + 100 * sizeof(int));
if (p == NULL)
{
    perror("malloc");
    return 0 ;
}

p->i = 100;
for (i = 0; i < 100; i++)
{
    p->arr[i] = i + 1;
}
free(p);
p = NULL;
return 0;
}

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

6.3柔性数组的优势

代码1：

int i = 0;
ts* p = (ts*)malloc(sizeof(ts) + 100 * sizeof(int));
if (p == NULL)
{
    perror("malloc");
    return 0 ;
}

p->i = 100;
for (i = 0; i < 100; i++)
{
    p->arr[i] = i + 1;
}
free(p);
p = NULL;

代码2：

typedef struct st
{
    int i;
    int* p;
}ts;
ts* ps = (ts*)malloc(sizeof(ts));
ps->i = 100;
ps->p = (int*)malloc(ps->i * sizeof(int));
for (i = 0; i < 100; i++)
{
    ps->p[i] = i + 1;
}
//释放空间
free(ps->p);//先释放里面
ps->p = NULL;
free(ps);//后释放外面
ps = NULL;

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

一个小脑袋
关注
专栏目录
C语言——动态内存
保护小周ღ的博客
04-14 3115
大家好！我是保护小周，本期为大家带来超详细的C语言——动态内存管理，论动态内存在C++/C中的重要性，学好动态内存约等于看穿了C语言~确定不来看看嘛 ~ 1.为什么存在动态内存 2.动态内存函数的介绍 3.常见的动态内存错误 4.经典笔试题 5.柔性数组 快来跟我一起学习吧！ ......
C语言要点—— 动态内存
03-18
它提供了灵活的内存管理能力，其中动态内存分配是C语言的一个重要特性。在使用动态内存时，我们必须了解相关的函数如malloc和free、calloc和realloc、以及如何管理堆、栈和静态存储区。此外，野指针是动态内存操作中...
C语言—动态内存管理
怀秋秋意的博客
03-11 285
详解C语言中的内存的动态分配管理，干货满满，保姆级教程
【C语言】动态内存管理
2301_77459845的博客
07-26 669
C语言提供了一个动态内存开辟的函数——malloc这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。malloc函数的使用申请40个字节 int * p =(int *)(malloc)(40);return 1;for(i = 0;i < 10;如果开辟成功，则返回一个指向开辟好空间的指针。如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
【C语言】动态内存管理（详细！！！）
最新发布
2401_83871176的博客
08-20 990
用于存放函数的参数值、局部变量的值等。这部分内存由编译器自动分配和释放，函数的调用过程就是通过栈这种数据结构实现的。一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收。分配方式类似于链表。（static）存放全局变量、静态数据。程序结束后由系统释放。存放函数体（类成员函数和全局函数）的二进制代码。这部分内存区域通常是只读的，以防止程序意外地修改其指令。喜欢记得！如有不足欢迎评论区指出~
C语言的动态内存管理
weiguangxingchen的博客
10-18 274
C语言的特点之一是功能强大且灵活，但是我在学习C语言的过程中发现在写代码时，如果我像要在储存数据就要在开辟特定大小的内存存放数据，那么以功能强大且灵活的C语言有没有提供一种更加灵活的选择来分配内存呢？C语言提供了库函数供我们动态分配和释放内存。
【C语言】内存你知多少？详解C语言动态内存管理
菜菜成长为后端开发大佬
06-22 1342
谈谈我们经常用的内存动态内存管理
C语言——彩票管理系统.zip
06-13
在本项目中，"C语言——彩票管理系统" 是一个基于C语言实现的彩票销售与管理的应用程序。这个系统设计的目的是为了模拟实际彩票销售过程中的各种功能，包括彩票的购买、开奖、兑奖等环节，同时也可能包含了对彩票...
C语言——学生宿舍管理系统.doc
10-03
《C语言——学生宿舍管理系统》 本系统是一个基于C语言实现的学生宿舍管理程序，它能够进行学生信息的录入、查询、修改、删除等操作，并且支持数据的保存和读取。下面将详细介绍该系统的关键组成部分及其功能。 1....
c语言篇（动态内存管理）
小马同学的博客
12-10 5272
动态内存管理，很重要的一篇文章，看完这篇让你深入理解动态内存的设置，和避免开辟的时候出现的一些问题！！！！
C语言-动态内存管理详解
2301_81486828的博客
01-24 1321
所以，如果我们把结构体的内存以及其成员要的内存⼀次性分配好了，并返 回给⽤户⼀个结构体指针，⽤户做⼀次free就可以把所有的内存也给释放掉。有时候我们需要的空间⼤⼩在程序运⾏的时候才能知 道，那数组的编译时开辟空间的⽅式就不能满⾜了。• 有时会我们发现过去申请的空间太⼩了，有时候我们⼜会觉得申请的空间过⼤了，那为了合理的时 候内存，我们⼀定会对内存的⼤⼩做灵活的调整。• 包含柔性数组成员的结构⽤malloc ()函数进⾏内存的动态分配，并且分配的内存应该⼤于结构的⼤ ⼩，以适应柔性数组的预期⼤⼩。
C语言：动态内存管理
weixin_57663528的博客
10-09 572
详细介绍malloc，free，calloc，realloc等函数
【C语言】动态内存管理详解
是阿建吖！
04-07 781
动态内存管理详解
C语言动态内存管理
小何代码咖啡馆
01-08 865
变量和数组创建的空间固定，有时候需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足动态内存管理，而动态内存管理可以灵活地申请和释放空间。
C语言指针动态内存管理技术
文件的标题强调了核心概念——“c语言指针内存分配”，而描述则指明了文件内容的具体知识点——“c语言指针实现动态分配和释放内存”，并涉及到了相关的C语言标准库函数。根据文件的标签，“c语言”，我们可以判断...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值