【C进阶】分析 C/C++程序的内存开辟与柔性数组(内有干货)

简介: 【C进阶】分析 C/C++程序的内存开辟与柔性数组(内有干货)

前言:


       本文是对于动态内存管理知识后续的补充,以及加深对其的理解。对于动态内存管理涉及的大部分知识在这篇文章中 ---- 【C进阶】 动态内存管理_Dream_Chaser~的博客-CSDN博客

     本文涉及的知识内容主要在两方面:

  • 简单解析C/C++程序的内存开辟
  • 分析柔性数组的知识点


C/C++程序的内存开辟区域📍


1.栈区(stack)

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


2. 堆区(heap)

       一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 。分

配方式类似于链表。


3. 数据段(静态区)(static)

       存放全局变量、静态数据。程序结束后由系统释放。


4. 代码段

       存放函数体(类成员函数和全局函数)的二进制代码。      

📃内存区域划分图:

8bbb11245d3a445ea320ce5cb2dee15e.png

       📚有了这幅图,我们就可以更好的理解在C语言初识中讲的static关键字修饰局部变量的例子了。

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


柔性数组💨


       柔性数组(Flexible Array)是一种在编程语言中用于表示可变长度数组的数据结构。它允许在声明数组时不指定数组的长度,而是在运行时根据需要动态分配内存空间

   柔性数组最常见的应用是在C语言中。在C语言中,柔性数组是一种特殊的结构体成员,其长度可以在结构体实例化之前或之后进行动态调整。

   C99 中结构中的最后一个元素允许是未知大小的数组这就叫做『柔性数组』成员

啥意思呢,用代码说话

       在vs编译器环境下,以下两种写法均支持

       第一种写法(使用空方括号[ ])是更常见和更符合标准的写法,可以在大多数编译器环境下使用。

struct S
{
  int n;
  char c;
  int arr[];//柔性数组成员
};


    第二种写法(指定大小为0)在某些特定的编译器(vs)扩展中可能有效,但不具有通用性和可移植性

struct S
{
  int n;
  char c;
  int arr[0];//柔性数组成员(指定大小)
};


柔性数组的特点

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

typedef struct st_type
{
 int i;//必须至少一个其他成员
 int a[0];//👈柔性数组成员
}type_a;


错误写法:

struct SA
{
  int arr[];//柔性数组成员
};


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

417f95f2e1aa42c5a44954d89d31bbb3.png

struct S
{
  int n;
  char c;
  int arr[];//柔性数组成员
};
int main()
{
  printf("%d", sizeof(struct S));
}

🚩8

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

#include<stdio.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>
int main()
{
    //arr需要开辟的空间是10个int
    //                     n与c需要开辟的内存           arr数组需要开辟的内存空间
    //                           8                         40
  struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
  return 0;
}


图解:

e8a5009ac954459dbfeca2dbf9b80df8.png


柔性数组的使用

代码实现🎯

#include<stdio.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>
//柔性数组
struct S
{
  int n;
  char c;
  int arr[];//柔性数组成员
};
int main()
{
  struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
  if (ps == NULL)
  {
    printf("%s\n",strerror(errno));
    return 1;
  }
  //使用
  ps->n = 100;
  ps->c = 'w';
  int i = 0;
  for ( i = 0; i < 10; i++)
  {
    ps->arr[i] = i;
  }
  for (i = 0; i < 10; i++)
  {
    printf("%d\n", ps->arr[i]);
  }
  //调整arr数组的大小(注意这是重新改变大小,不是说在原来空间后面增加,比如说原来是48,那么现在就是88)
  struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(int));
  if (ptr == NULL)
  {
    printf("%s\n,sterror(error)");
    return 1;
  }
  else
  {
    ps = ptr;
  }
  //再次使用
  //....
  //释放
  free(ps);
  ps = NULL;
  printf("%d\n", sizeof(struct S));
  return 0;
}


调试一下,看看空间大小如何

malloc的空间,58-30=28(16进制),换成十进制刚好为40,刚好是10int的字节大小

e2ab6f49643443998d982695e8a5ca91.png


柔性数组的优势


方案一:柔性数组的方案

#include<stdio.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>
//柔性数组
struct S
{
  int n;
  char c;
  int arr[];//柔性数组成员
};
int main()
{
  struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
  if (ps == NULL)
  {
    printf("%s\n",strerror(errno));
    return 1;
  }
  //使用
  ps->n = 100;
  ps->c = 'w';
  int i = 0;
  for ( i = 0; i < 10; i++)
  {
    ps->arr[i] = i;
  }
  for (i = 0; i < 10; i++)
  {
    printf("%d\n", ps->arr[i]);
  }
  //调整arr数组的大小(注意这是重新改变大小,不是说在原来空间后面增加,比如说原来是48,那么现在就是88)
  struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(int));
  if (ptr == NULL)
  {
    printf("%s\n,sterror(error)");
    return 1;
  }
  else
  {
    ps = ptr;
  }
  //再次使用
  //....
  //释放
  free(ps);
  ps = NULL;
  printf("%d\n", sizeof(struct S));
  return 0;
}


描述:

malloc 1次 ,free 1次

方案二:结构中指针方案

定义一个指针变量指向一块新的区域,像下面这样

图解:

e25a19ab78ec4308851111d2842b5ab1.png

代码实现✨

struct S
{
  int n;
  char c;
  int* arr;
};
int main()
{
  struct S* ps = (struct S*)malloc(sizeof(struct S));
  if (ps == NULL)
  {
    perror("malloc");
    return 1;
  }
  int* ptr = (int*)malloc(10 * sizeof(int));
  if (ptr == NULL)
  {
    perror("malloc2");
    return 1;
  }
  else
  {
    ps->arr = ptr;
  }
  //使用
  ps->n = 100;
  ps->c = 'w';
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    ps->arr[i] = i;
  }
  //打印
  for (i = 0; i < 10; i++)
  {
    printf("%d ",ps->arr[i]);
  }
  //扩容 - 调整arr的大小
  ptr = realloc(ps->arr,20*sizeof(int));
  if (ptr == NULL)
  {
    perror("realloc");
    return 1;
  }
  else
  {
    ps->arr = ptr;
  }
  //使用
  //释放
  free(ps->arr);
  ps->arr = NULL;
  free(ps);
  ps = NULL;
  return 0;
}


描述:

malloc 2次,free 2次

       上面的方案一和方案二谁的优势更优呢,显然是方案一

个人的理解:

       从写代码的方面来说,malloc越多,free的越多,空间的维护难度就更高,所以

  方案一实现起来更加简单,空间维护更加简单,容易维护空间,不易出错

       方案二来说,一旦忘记free一次的话,可能会导致内存泄漏等问题,所以维护难度加大,容易出错

  还有区别就是:

       在堆区上申请内存的话,每一次malloc申请的空间,第二次malloc申请的空间跟第一次申请的空间在地址上不一定是连续的,随机性很高,随着malloc申请的数量越多,那么在内存和内存之间留下的空隙就会越多,这种空隙我们叫做为内存碎片

  还有区别就是:

       在堆区上申请内存的话,每一次malloc申请的空间,第二次malloc申请的空间跟第一次申请的空间在地址上不一定是连续的,随机性很高,随着malloc申请的数量越多,那么在内存和内存之间留下的空隙就会越多,这种空隙我们叫做为内存碎片

028c73329645402baf31aeb222f5bb25.png

总结

①方案一:malloc次数少,内存碎片就会较少,内存的使用率就较高一些

②方案二:malloc次数多,内存碎片就会增多,内存的使用率就下降了

上述 方案 1 和 方案 2 可以完成同样的功能,但是 方法 1 的实现有两个好处:

⛳第一个好处是: 方便内存释放

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

⛳第二个好处是:这样有利于访问速度.

       连续的内存有益于提高访问速度,也有益于减少内存碎片。(其实,我个人觉得也没多高了,反正你跑不了要用做偏移量的加法来寻址)

   本文结束,如有错误,欢迎指正,感谢支持!

相关文章
|
1月前
|
Web App开发 监控 JavaScript
监控和分析 JavaScript 内存使用情况
【10月更文挑战第30天】通过使用上述的浏览器开发者工具、性能分析工具和内存泄漏检测工具,可以有效地监控和分析JavaScript内存使用情况,及时发现和解决内存泄漏、过度内存消耗等问题,从而提高JavaScript应用程序的性能和稳定性。在实际开发中,可以根据具体的需求和场景选择合适的工具和方法来进行内存监控和分析。
|
12天前
|
并行计算 算法 测试技术
C语言因高效灵活被广泛应用于软件开发。本文探讨了优化C语言程序性能的策略,涵盖算法优化、代码结构优化、内存管理优化、编译器优化、数据结构优化、并行计算优化及性能测试与分析七个方面
C语言因高效灵活被广泛应用于软件开发。本文探讨了优化C语言程序性能的策略,涵盖算法优化、代码结构优化、内存管理优化、编译器优化、数据结构优化、并行计算优化及性能测试与分析七个方面,旨在通过综合策略提升程序性能,满足实际需求。
36 1
|
14天前
|
JavaScript
如何使用内存快照分析工具来分析Node.js应用的内存问题?
需要注意的是,不同的内存快照分析工具可能具有不同的功能和操作方式,在使用时需要根据具体工具的说明和特点进行灵活运用。
35 3
|
21天前
|
存储 缓存 C语言
【c++】动态内存管理
本文介绍了C++中动态内存管理的新方式——`new`和`delete`操作符,详细探讨了它们的使用方法及与C语言中`malloc`/`free`的区别。文章首先回顾了C语言中的动态内存管理,接着通过代码实例展示了`new`和`delete`的基本用法,包括对内置类型和自定义类型的动态内存分配与释放。此外,文章还深入解析了`operator new`和`operator delete`的底层实现,以及定位new表达式的应用,最后总结了`malloc`/`free`与`new`/`delete`的主要差异。
41 3
|
28天前
|
开发框架 监控 .NET
【Azure App Service】部署在App Service上的.NET应用内存消耗不能超过2GB的情况分析
x64 dotnet runtime is not installed on the app service by default. Since we had the app service running in x64, it was proxying the request to a 32 bit dotnet process which was throwing an OutOfMemoryException with requests >100MB. It worked on the IaaS servers because we had the x64 runtime install
|
28天前
|
存储 编译器 Linux
【c++】类和对象(上)(类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针)
本文介绍了C++中的类和对象,包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用,以及如何使用访问限定符控制成员的访问权限。此外,还讨论了对象的内存分配规则和this指针的使用场景,帮助读者深入理解面向对象编程的核心概念。
66 4
|
29天前
|
Ubuntu Linux Shell
C++ 之 perf+火焰图分析与调试
【11月更文挑战第6天】在遇到一些内存异常的时候,经常这部分的代码是很难去进行分析的,最近了解到Perf这个神器,这里也展开介绍一下如何使用Perf以及如何去画火焰图。
|
1月前
|
Web App开发 JavaScript 前端开发
使用 Chrome 浏览器的内存分析工具来检测 JavaScript 中的内存泄漏
【10月更文挑战第25天】利用 Chrome 浏览器的内存分析工具,可以较为准确地检测 JavaScript 中的内存泄漏问题,并帮助我们找出潜在的泄漏点,以便采取相应的解决措施。
188 9
|
17天前
|
缓存 Prometheus 监控
Elasticsearch集群JVM调优设置合适的堆内存大小
Elasticsearch集群JVM调优设置合适的堆内存大小
150 1
|
7天前
|
存储 监控 算法
深入探索Java虚拟机(JVM)的内存管理机制
本文旨在为读者提供对Java虚拟机(JVM)内存管理机制的深入理解。通过详细解析JVM的内存结构、垃圾回收算法以及性能优化策略,本文不仅揭示了Java程序高效运行背后的原理,还为开发者提供了优化应用程序性能的实用技巧。不同于常规摘要仅概述文章大意,本文摘要将简要介绍JVM内存管理的关键点,为读者提供一个清晰的学习路线图。

热门文章

最新文章