详解C语言中动态内存管理及柔性数组的使用

目录
  • 一、malloc
  • 二、free
  • 三、calloc
  • 四、realloc
    • 1、realloc在扩容时的情况
    • 2、realloc也能实现malloc功能
  • 五、使用动态内存的常见错误
    • 1、free空指针
    • 2、对动态开辟的空间越界访问
    • 3、对非动态开辟内容free
    • 4、只free动态开辟空间的一部分
    • 5、对同一块内存多次free
    • 6、动态内存空间忘记释放(内存泄漏)
  • 六、柔性数组
    • 1、柔性数组的概念
    • 2、柔性数组的特点
    • 3、柔性数组的使用场景
    • 4、柔性数组的优点

一、malloc

这个函数向堆区申请一块连续的空间,并返回这块内存的地址。

int main()
{
    int* p = (int*)malloc(40);
    if (p == NULL)
    {
        printf("%s\n", strerror(errno));
        return 1;
    }
    free(p);
    p = NULL;
    return 0;
}

如果开辟失败,则返回一个NULL指针,因此malloc的返回值一定要做检查。

如果参数 size为0,malloc的行为是标准是未定义的,取决于编译器。

二、free

free函数用来释放动态开辟的内存。free的指针必须是指向动态内存空间的起始地址。

如果参数 ptr 指向的空间不是动态开辟的,那free函数的行为是未定义的。

如果参数 ptr 是NULL指针,则函数什么事都不做。

三、calloc

num:要动态开辟的元素个数

size:每个元素的大小

calloc=malloc+memset

calloc和malloc的区别就在于calloc会将动态内存开辟的空间全部初始化为0

四、realloc

ptr:需要扩容的原始地址

size:扩容后的总大小

1、realloc在扩容时的情况

1、扩容时后方空间足够,将在后方继续扩容,返回原始地址

2、扩容时后方空间已被使用,将在新的一块区域进行扩容,并将原始数据拷贝至新的区域,free原始地址指向的内存,并返回内存块的地址。

3、空间不足,无法扩容,返回空指针

2、realloc也能实现malloc功能

int main()
{
    int* p = (int*)realloc(NULL, 40);
    return 0;
}

realloc在当malloc使用时,第一个参数传空指针即可。

五、使用动态内存的常见错误

1、free空指针

void text()
{
    int* p = (int*)realloc(NULL, 40);
    if (p == NULL)//判断p是否为空指针
    {
        return;
    }
    *p = 20;
}

如果开辟空间后,没有判断指针p是否是空指针,如果动态内存开辟失败,那么*p将会解引用空指针。

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

void text()
{
    int* p = (int*)realloc(NULL, 40);
    int* m = p;
    if (p == NULL)
    {
        return;
    }
    for (int i = 0; i <= 10; i++)
    {
        p[i] = i;//越界
        p++;
    }
}

3、对非动态开辟内容free

void text()
{
    int arr[] = {1,2,3};
    int* p = arr;
    free(p);//不能对非动态开辟的空间进行free
}

4、只free动态开辟空间的一部分

void text()
{
    int* p = (int*)malloc(40);
    p++;
    free(p);//p不再指向动态开辟空间的起始位置
}

实际写代码的时候还是得多注意这种情况,指针p在使用的过程中已经不再是初始位置,free(p)会崩溃。

5、对同一块内存多次free

void text()
{
    int* p = (int*)realloc(NULL, 40);
    free(p);
    //p = NULL;

    free(p);
}

free(p)后及时将p置为空指针,哪怕p被多次free也没问题。

6、动态内存空间忘记释放(内存泄漏)

void text()
{
    int* p = (int*)realloc(NULL, 40);
    int a = 0;
    scanf("%d", &a);
    if (a == 5)
        return;
    free(p);
    p = NULL;
}

当函数提前终止,没有机会走到free,可能会造成内存泄漏

另一种可能是调用了动态开辟内存的函数,使用者未在外部进行free

六、柔性数组

1、柔性数组的概念

C99中,结构体中最后一个成员变量可以是未知大小的数组

struct S
{
    int a;
    int arr[0];//这里的arr[0]代表未知大小的数组
};
//或者如下写法:
struct S
{
    int a;
    int arr[];
};

2、柔性数组的特点

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

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

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

3、柔性数组的使用场景

场景:将结构体中所有的成员变量全部在堆区开辟

使用柔性数组:

struct S
{
    int a;
    int arr[0];
};
int main()
{
    struct S s;
    struct S* ps = &s;
    ps = (struct S*)realloc(NULL,sizeof(s) + 40);//首次开辟空间,传NULL
    if (ps == NULL)
    {
        exit(-1);
    }
    free(ps);
    ps = NULL;
    return 0;
}

注意此处的realloc第一个参数传入的是NULL而不是&s,传入&s会崩溃,是因为这是第一次动态内存开辟,此处传入NULL相当于使用malloc

完成开辟后s在内存中的存储如下图:

使用常规结构体:

struct S
{
    int a;
    int* parr;
};
int main()
{
    struct S* p = (struct S*)malloc(sizeof(struct S));//对结构体动态开辟空间
    if (p == NULL)
    {
        exit(-1);
    }
    int* tmp= (int*)malloc(sizeof(int) * 2);//在堆区动态开辟一块空间
    if (tmp == NULL)
    {
        exit(-1);
    }
    p->parr = tmp;
    free(p->parr);//释放时,需要先释放p->parr指向的空间
    p->parr = NULL;
    free(p);//再将结构体指针p指向的空间释放
    p = NULL;
    return 0;
}

完成开辟后s在内存中的存储如下图:

4、柔性数组的优点

1、在上述条件下,使用柔性数组方便动态内存释放。如果我们的代码是在一个给别人用的函数中,你在里面做了二次内存分配,并把整个结构体返回给用户。用户调用free可以释放结构体,但是用户并不知道这个结构体内的成员也需要free,可能会造成内存泄漏。所以,如果我们把结构体的内存以及其成员要的内存一次性分配好了,并返回给用户一个结构体指针,用户做一次free就可以把所有的内存给释放掉。

2、连续的内存有益于提高访问速度,也有益于减少内存碎片。

以上就是详解C语言中动态内存管理及柔性数组的使用的详细内容,更多关于C语言 动态内存管理 柔性数组的资料请关注我们其它相关文章!

(0)

相关推荐

  • C语言柔性数组实例详解

    本文实例分析了C语言柔性数组的概念及用法,对于进一步学习C程序设计有一定的借鉴价值.分享给大家供大家参考.具体如下: 一般来说,结构中最后一个元素允许是未知大小的数组,这个数组就是柔性数组.但结构中的柔性数组前面必须至少一个其他成员,柔性数组成员允许结构中包含一个大小可变的数组,sizeof返回的这种结构大小不包括柔性数组的内存.包含柔数组成员的结构用malloc函数进行内存的动态分配,且分配的内存应该大于结构的大小以适应柔性数组的预期大小.柔性数组到底如何使用? 不完整类型 C和C++对于不完

  • C语言中动态内存管理图文详解

    目录 1.动态内存开辟的原因 2.动态内存函数的介绍 2.1malloc和free 2.2calloc 2.3realloc 3.常见的动态内存错误 3.1对NULL指针的解引用操作 3.2对动态开辟空间的越界访问 3.3对非动态开辟内存使用free 3.4使用释放一块动态开辟内存的一部分 3.5对同一块动态内存多次释放 3.6动态开辟内存忘记释放(内存泄漏) 4.练习 4.1练习1 4.1练习2 4.3练习3 4.4练习4 5.C/C++程序的内存开辟 总结 1.动态内存开辟的原因 常见的内存

  • 详解C语言之柔性数组

    目录 定义 特点 具体使用例 总结 定义 可调整大小的数组 以0大小数组或无大小数组定义在结构体的最后一个元素中 特点 1.结构体中的柔性数组前必须包含至少一个其他成员. 2.sizeof返回的这种结构体大小不包含柔性数组的内存. 3.包含柔性数组成员的结构用malloc()函数进行内存的动态分配,并且分配的大小应该大于结构的大小,以适应柔性数组的预期大小. 具体使用例  实现可调整大小的数组还可用一般的方法: 但是相比之下柔性数组有如下优点: 1.方便内存释放,如果分配两次内存,则需要释放两次

  • C语言柔性数组详解

    目录 前言 一.柔性数组是什么? 二.柔性数组的特点 三.柔性数组的优点 总结 前言 可能大家第一眼看到这个标题会有点懵,到底什么是柔性数组,我怎么从来没听说过?但柔性数组确实是存在的,也经常会出现在一些公司的面试题中,今天就跟着笔者来学习一下柔性数组吧. 提示:以下是本篇文章正文内容,下面案例可供参考 一.柔性数组是什么? C99中,结构体中的最后一个元素允许是未知大小的数组,这就叫作柔性数组,for example: struct st_type { int i; int a[0];//柔性

  • C语言动态内存管理介绍

    目录 前言: C 语言为内存的分配和管理提供了几个函数: 1.malloc() 用法 2.calloc() 用法 3.realloc() 与 free() 用法 前言: 简单记录一下,内存管理函数 为什么使用动态内存呢? 简单理解就是可以最大限度调用内存 用多少生成多少,不用时就释放而静止内存不能释放 动态可避免运行大程序导致内存溢出 C 语言为内存的分配和管理提供了几个函数: 头文件:<stdlib.h> 注意:void * 类型表示未确定类型的指针  1.malloc() 用法  分配一块

  • C语言 柔性数组的使用详解

    目录 一.柔性数组的特点 二.柔性数组的使用 1.如何使用柔性数组 2.不用柔性数组的话有什么代替 三.柔性数组的优势 1.方便内存释放 2.提高访问速度 一.柔性数组的特点 struct S { int x; int a[]; }; int main() { printf("%d", sizeof(S)); } 这段代码的输出是什么? 我们打印结构体S所占空间的大小,这个a[]占多少字节呢? 输出结果是4,可一个int类型的x就是4了,a[]去哪了?好奇怪哦. 原来,这是一种柔性数组

  • 深入了解C语言的动态内存管理

    目录 一.为什么会存在动态内存 二.动态内存函数 1.malloc和free 2.calloc 3.realloc 三.动态内存函数常见错误 2.对NULL指针进行解引用操作 3.使用free释放一块动态开辟内存的一部分 4.对静态内存进行free释放 5.对同一内存空间多次释放 6.动态开辟空间忘记释放 四.经典笔试题 1.笔试1 2.笔试2 3.笔试3 总结 一.为什么会存在动态内存 int data=20;//在栈空间上开辟4个字节空间 char ch[5]={0};//在栈开辟5个字节连

  • C语言动态内存管理的实现

    目录 1. 摘要 2. 为什么存在动态内存管理 3. 动态内存函数 3.1 malloc 3.2 free 3.3 calloc 3.4 realloc 4. 常见的动态内存错误 5. 几个经典笔试题 参考答案 6. 参考文献 1. 摘要 本文主要详解C语言中的动态内存分配 2. 为什么存在动态内存管理 我们先来看一段变量的声明: double x = 1.000000; char str[] = "abcdef"; 好的,上述变量的声明有何特点呢? 请思考一下,我的朋友. 对,没错,

  • 详解C语言中动态内存管理及柔性数组的使用

    目录 一.malloc 二.free 三.calloc 四.realloc 1.realloc在扩容时的情况 2.realloc也能实现malloc功能 五.使用动态内存的常见错误 1.free空指针 2.对动态开辟的空间越界访问 3.对非动态开辟内容free 4.只free动态开辟空间的一部分 5.对同一块内存多次free 6.动态内存空间忘记释放(内存泄漏) 六.柔性数组 1.柔性数组的概念 2.柔性数组的特点 3.柔性数组的使用场景 4.柔性数组的优点 一.malloc 这个函数向堆区申请

  • 详解C语言之动态内存管理

    目录 开辟动态内存的函数 释放开辟的动态内存空间的函数 错误信息函数 具体使用例: 常见的动态内存错误 总结 先来了解一下动态管理内存所需用到的函数 开辟动态内存的函数 1.malloc函数:void* malloc(size_t size); 功能:开辟一块大小为size单位为字节的动态空间.若开辟成功返回函数开辟空间的无类型指针,若开辟失败则返回空指针NULL 2.calloc函数: void* calloc(size_t num, size_t size); 功能:开辟一块能容纳下num个

  • C语言动态内存管理malloc柔性数组示例详解

    目录 1.1为什么存在动态内存管理 1.2动态内存管理函数 1.2.1malloc 1.2.2free 1.2.3calloc 1.2.4realloc 1.3动态内存管理函数易错点 1.3.1对NULL指针的解引用操作 1.3.2对动态开辟空间的越界访问 1.3.3对非动态开辟内存使用free释放 1.3.4使用free释放一块动态开辟内存的一部分 1.3.5对同一块动态内存多次释放 1.3.6动态开辟内存忘记释放(内存泄漏) 2.1常见相关笔试题 2.2C/C++语言中的内存开辟 2.3柔性

  • 详解C语言中的内存四区模型及结构体对内存的使用

    内存四区 1.代码区 代码区code,程序被操作系统加载到内存的时候,所有的可执行代码都加载到代码区,也叫代码段,这块内存是不可以在运行期间修改的. 2.静态区 所有的全局变量以及程序中的静态变量都存储到静态区. 3.栈区 栈stack是一种先进后出的内存结构,所有的自动变量,函数的形参都是由编译器自动放出栈中,当一个自动变量超出其作用域时,自动从栈中弹出.对于自动变量,什么时候入栈,什么时候出栈,是不需要程序控制的,由C语言编译器.实现栈不会很大,一般都是以K为单位的. 当栈空间以满,但还往栈

  • 一文详解C++中动态内存管理

    目录 前言 1.C/C++程序的内存开辟 2.C语言中动态内存管理方式:malloc/calloc/realloc/free 2.1malloc.calloc.realloc区别? 3.C++内存管理方式 3.1 new/delete操作内置类型 3.2 new和delete操作自定义类型 3.3new和malloc处理失败 4.operator new与operator delete函数 4.1 operator new与operator delete函数 4.1.1 我们看看operator

  • 详解C语言中的动态内存管理

    目录 一.动态内存管理 1.1为什么要有动态内存管理 1.2动态内存介绍 1.3常见的动态内存错误 一.动态内存管理 1.1为什么要有动态内存管理 1.1.1  在c语言中我们普通的内存开辟是直接在栈上进行开辟的 int i = 20;//在栈空间上开辟四个字节 int arr[10]={0}; //在栈中连续开辟四十个字节 这样开辟的特点是: (1)他所开辟的空间是固定的 (2)数组在申明的时候,必须指定数组的长度,它所需要的内存在编译时分配 但对于空间的需求,我们有的时候并不知道,有可能空间

  • 详细谈谈C语言中动态内存

    目录 前言 1.关于动态内存的函数 1.1malloc和free函数 1.2calloc函数 1.3realloc函数 2.常见的动态内存错误 2.1对NULL指针解引用 2.2对动态内存开辟的空间越界访问 2.3 对非动态开辟内存使用free释放 2.4 使用free释放一块动态开辟内存的一部分 2.5对同一块动态内存多次释放 2.6内存泄漏 补充:为什么要引入动态内存分配 总结 前言 关于动态内存管理,可能有学习过的小伙伴,也有没有听说过的.没有听说过的小伙伴会觉得很奇怪啊,为什么要动态开辟

  • 详解Go语言中泛型的实现原理与使用

    目录 前言 问题 解决方法 类型约束 重获类型安全 泛型使用场景 性能 虚拟方法表 单态化 Go 的实现 结论 前言 原文:A gentle introduction to generics in Go byDominik Braun 万俊峰Kevin:我看了觉得文章非常简单易懂,就征求了作者同意,翻译出来给大家分享一下. 本文是对泛型的基本思想及其在 Go 中的实现的一个比较容易理解的介绍,同时也是对围绕泛型的各种性能讨论的简单总结.首先,我们来看看泛型所解决的核心问题. 问题 假设我们想实现

  • 详解Go语言中切片的长度与容量的区别

    目录 切片的声明 切片的长度和容量 切片追加元素后长度和容量的变化 append 函数 切片的源代码学习 切片的结构体 切片的扩容 总结 切片的声明 切片可以看成是数组的引用(实际上切片的底层数据结构确实是数组).在 Go 中,每个数组的大小是固定的,不能随意改变大小,切片可以为数组提供动态增长和缩小的需求,但其本身并不存储任何数据. // 数组的声明 var a [5]int //只指定长度,元素初始化为默认值0 var a [5]int{1,2,3,4,5} // 切片的声明 // 方法1:

随机推荐