思享工具箱

转：程序内存空间（代码段、数据段、堆栈段）

摘要：
数据段属于静态内存分配。这部分区域的大小在程序运行前就已经确定，并且内存区域通常属于只读,某些架构也允许代码段为可写，即允许修改程序。数据段包含经过初始化的全局变量以及它们的值。BSS段的大小从可执行文件中得到，然后链接器得到这个大小的内存块，紧跟在数据段后面。包含数据段和BSS段的整个区段此时通常称为数据区。堆栈段：1.为函数内部的局部变量提供存储空间。

https://blog.csdn.net/ywcpig/article/details/52303745

在冯诺依曼的体系结构中，一个进程必须有：代码段，堆栈段，数据段。

进程的虚拟地址空间图示如下：

转：程序内存空间（代码段、数据段、堆栈段）第1张转：程序内存空间（代码段、数据段、堆栈段）第2张

BSS段：BSS段（bss segment）通常是指用来存放程序中未初始化的全局变量的一块内存区域。BSS是英文Block Started by Symbol的简称。BSS段属于静态内存分配。

数据段：数据段（data segment）通常是指用来存放程序中已初始化的全局变量的一块内存区域。数据段属于静态内存分配。

代码段：代码段（code segment/text segment）通常是指用来存放程序执行代码的一块内存区域。这部分区域的大小在程序运行前就已经确定，并且内存区域通常属于只读, 某些架构也允许代码段为可写，即允许修改程序。在代码段中，也有可能包含一些只读的常数变量，例如字符串常量等。

堆（heap）：堆是用于存放进程运行中被动态分配的内存段，它的大小并不固定，可动态扩张或缩减。当进程调用malloc等函数分配内存时，新分配的内存就被动态添加到堆上（堆被扩张）；当利用free等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减）

栈(stack)：栈又称堆栈， 是用户存放程序临时创建的局部变量，也就是说我们函数括弧“{}”中定义的变量（但不包括static声明的变量，static意味着在数据段中存放变量）。除此以外，在函数被调用时，其参数也会被压入发起调用的进程栈中，并且待到调用结束后，函数的返回值也会被存放回栈中。由于栈的先进后出特点，所以栈特别方便用来保存/恢复调用现场。从这个意义上讲，我们可以把堆栈看成一个寄存、交换临时数据的内存区。

它是由操作系统分配的，内存的申请与回收都由OS管理。

注意：

全局的未初始化变量存在于.bss段中，具体体现为一个占位符；全局的已初始化变量存于.data段中；而函数内的自动变量都在栈上分配空间。.bss是不占用可执行文件空间的，其内容由操作系统初始化（清零）；而.data却需要占用，其内容由程序初始化，因此造成了上述情况。

bss段（未手动初始化的数据）并不给该段的数据分配空间，只是记录数据所需空间的大小。
data（已手动初始化的数据）段则为数据分配空间，数据保存在目标文件中。 数据段包含经过初始化的全局变量以及它们的值。BSS段的大小从可执行文件中得到 ，然后链接器得到这个大小的内存块，紧跟在数据段后面。当这个内存区进入程序的地址空间后全部清零。包含数据段和BSS段的整个区段此时通常称为数据区。

堆栈段：

1. 为函数内部的局部变量提供存储空间。

2. 进行函数调用时，存储“过程活动记录”。

3. 用作暂时存储区。如计算一个很长的算术表达式时，可以将部分计算结果压入堆栈。

数据段（静态存储区）：

　　包括BSS段（Block Started by Symbol）的数据段。BSS段存储未初始化或初始化为0的全局变量、静态变量，具体体现为一个占位符，并不给该段的数据分配空间，只是记录数据所需空间的大小。数据段存储经过初始化的全局和静态变量。

  1. #defineDEBUG"debug"
  3. intspace[1024][1024];
  4. intdata=1;
  5. intno_data=0;
  7. intmain()
  8. {
  9. char*a=DEBUG;
  10. return1;
  11. }

使用nm查看后

  1. 0000000000600660d_DYNAMIC
  2. 00000000006007f8d_GLOBAL_OFFSET_TABLE_
  3. 0000000000400578R_IO_stdin_used
  4. w_Jv_RegisterClasses
  5. 0000000000600640d__CTOR_END__
  6. 0000000000600638d__CTOR_LIST__
  7. 0000000000600650D__DTOR_END__
  8. 0000000000600648d__DTOR_LIST__
  9. 0000000000400630r__FRAME_END__
  10. 0000000000600658d__JCR_END__
  11. 0000000000600658d__JCR_LIST__
  12. 0000000000600820A__bss_start
  13. 0000000000600818D__data_start
  14. 0000000000400530t__do_global_ctors_aux
  15. 00000000004003e0t__do_global_dtors_aux
  16. 0000000000400580R__dso_handle
  17. w__gmon_start__
  18. 0000000000600634d__init_array_end
  19. 0000000000600634d__init_array_start
  20. 0000000000400490T__libc_csu_fini
  21. 00000000004004a0T__libc_csu_init
  22. U__libc_start_main@@GLIBC_2.2.5
  23. 0000000000600820A_edata
  24. 0000000000a00840A_end
  25. 0000000000400568T_fini
  26. 0000000000400358T_init
  27. 0000000000400390T_start
  28. 00000000004003bctcall_gmon_start
  29. 0000000000600820bcompleted.6347
  30. 000000000060081cDdata
  31. 0000000000600818Wdata_start
  32. 0000000000600828bdtor_idx.6349
  33. 0000000000400450tframe_dummy
  34. 0000000000400474Tmain
  35. 0000000000600830Bno_data
  36. 0000000000600840Bspace

可以看到变量data被分配在data段，而被初始化为0的no_data被分配在了BSS段。

.bss是不占用.exe文件空间的，其内容由操作系统初始化（清零）；而.data却需要占用，其内容由程序初始化。

注意：.data和.bss在加载时合并到一个Segment（Data Segment）中，这个Segment是可读可写的。

代码段：

又称为文本段。存储可执行文件的指令；也有可能包含一些只读的常数变量，例如字符串常量等。

.rodata段：存放只读数据，比如printf语句中的格式字符串和开关语句的跳转表。也就是你所说的常量区。例如，全局作用域中的 const int ival = 10，ival存放在.rodata段；再如，函数局部作用域中的printf("Hello world %d ", c);语句中的格式字符串"Hello world %d "，也存放在.rodata段。

但是注意并不是所有的常量都是放在常量数据段的，其特殊情况如下：

1）有些立即数与指令编译在一起直接放在代码段。

  1. intmain()
  2. {
  3. inta=10;
  4. return1;
  5. }

转：程序内存空间（代码段、数据段、堆栈段）第3张
a是常量，但是它没有被放入常量区，而是在指令中直接通过立即数赋值

2）对于字符串常量，编译器会去掉重复的常量，让程序的每个字符串常量只有一份。

  1. char*str="123456789";
  2. char*str1="helloworld";
  4. intmain()
  5. {
  6. char*a="helloworld";
  7. charb[10]="helloworld";
  8. return1;
  9. }

汇编代码如下：

  1. .file"hello.c"
  2. .globlstr
  3. .section.rodata
  4. .LC0:
  5. .string"123456789"
  6. .data
  7. .align8
  8. .typestr,@object
  9. .sizestr,8
  10. str:
  11. .quad.LC0
  12. .globlstr1
  13. .section.rodata
  14. .LC1:
  15. .string"helloworld"
  16. .data
  17. .align8
  18. .typestr1,@object
  19. .sizestr1,8
  20. str1:
  21. .quad.LC1
  22. .text
  23. .globlmain
  24. .typemain,@function
  25. main:
  26. .LFB0:
  27. .cfi_startproc
  28. pushq%rbp
  29. .cfi_def_cfa_offset16
  30. .cfi_offset6,-16
  31. movq%rsp,%rbp
  32. .cfi_def_cfa_register6
  33. movq$.LC1,-8(%rbp)
  34. movl$1819043176,-32(%rbp)
  35. movl$1919907695,-28(%rbp)
  36. movw$25708,-24(%rbp)
  37. movl$1,%eax
  38. leave
  39. .cfi_def_cfa7,8
  40. ret
  41. .cfi_endproc
  42. .LFE0:
  43. .sizemain,.-main
  44. .ident"GCC:(GNU)4.4.620110731(RedHat4.4.6-3)"
  45. .section.note.GNU-stack,"",@progbits

　　可以看到str1和a同时指向.rodata段中同一个LC1

3）用数组初始化的字符串常量是没有放入常量区的。

4）用const修饰的全局变量是放入常量区的，但是使用const修饰的局部变量只是设置为只读起到防止修改的效果，没有放入常量区。
5）有些系统中rodata段是多个进程共享的，目的是为了提高空间的利用率。

注意：程序加载运行时，.rodata段和.text段通常合并到一个Segment（Text Segment）中，操作系统将这个Segment的页面只读保护起来，防止意外的改写。

堆：

就像堆栈段能够根据需要自动增长一样，数据段也有一个对象，用于完成这项工作，这就是堆。堆区域是用来动态分配的内存空间，用 malloc 函数申请的，用free函数释放。calloc、realloc和malloc类似：前者返回指针的之前把分配好的内存内容都清空为零；后者改变一个指针所指向的内存块的大小，可以扩大和缩小，它经常把内存拷贝到别的地方然后将新地址返回。

转：程序内存空间（代码段、数据段、堆栈段）第4张

栈、堆辨析：

1、栈区（stack）：由编译器自动分配释放 ，存放函数的参数值、局部变量的值等。其操作方式类似于数据结构中的栈。
2、堆区（heap）：由程序员分配释放， 若程序员不释放，程序结束时可能由操作系统回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。

转：程序内存空间（代码段、数据段、堆栈段）第5张

程序示例：

1、举个例子说明各种变量存放在什么区：

  1. #include<stdlib.h>
  3. inta=123;//a在全局已初始化数据区
  5. char*p1;//p1在BSS区（未初始化全局变量）
  7. intmain()
  8. {
  9. intb;//b为局部变量，在栈区
  11. chars[]="abc";//s为局部数组变量，在栈区
  12. //"abc"为字符串常量，存储在已初始化数据区
  14. char*p1,*p2;//p1,p2为局部变量，在栈区
  16. char*p3="123456";//p3在栈区，"123456"在常量区(.rodata)
  18. staticintc=456;//c为局部（静态）数据，在已初始化数据区
  20. //静态局部变量会自动初始化(因为BSS区自动用0或NULL初始化)
  22. p1=(char*)malloc(10);//分配得来的10个字节的区域在堆区
  24. p2=(char*)malloc(20);//分配得来的20个字节的区域在堆区
  26. free(p1);
  28. free(p2);
  30. p1=NULL;//显示地将p1置为NULL，避免以后错误地使用p1
  32. p2=NULL;
  33. }


2、我们再写一个程序，输出各变量的内存空间：

  1. #include<stdio.h>
  2. #include<stdlib.h>
  4. externvoidafunc(void);
  6. externetext,edata,end;
  8. intbss_var;//未初始化全局变量存储在BSS段
  10. intdata_var=42;//初始化全局存储在数据段
  12. #defineSHW_ADR(ID,I)printf("The%sisataddress:%8x ",ID,&I);//打印地址宏
  14. intmain(intargc,char*argv[])
  15. {
  16. char*p,*b,*nb;
  18. printf("etextaddress:%8x edataaddress:%8x endaddress:%8x ",&etext,&edata,&end);
  20. SHW_ADR("main",main);//查看代码段main函数位置
  22. SHW_ADR("afunc",afunc);//查看代码段afunc函数位置
  24. printf(" bssLocatoin: ");
  25. SHW_ADR("bss_var",bss_var);//查看BSS段变量地址
  27. printf(" dataLocation: ");
  28. SHW_ADR("data_var",data_var);//查看数据段变量地址
  30. printf(" StackLoation: ");
  31. afunc();
  32. printf(" ");
  34. p=(char*)alloca(32);//从栈中分配空间
  36. if(p!=NULL)
  37. {
  38. SHW_ADR("stringpinstackstart",*p);
  39. SHW_ADR("stringpinstackend",*(p+32*sizeof(char)));
  40. }
  42. b=(char*)malloc(32*sizeof(char));//从堆中分配空间
  43. nb=(char*)malloc(16*sizeof(char));//从堆中分配空间
  45. printf(" HeapLocation: ");
  46. SHW_ADR("allocatedheapstart",*b);//已分配的堆空间的起始地址
  47. SHW_ADR("allocatedheapend",*(nb+16*sizeof(char)));//已分配的堆空间的结束地址
  49. printf(" p,bandnbinstack ");
  50. SHW_ADR("p",p);//显示栈中数据p的地址
  51. SHW_ADR("b",b);//显示栈中数据b的地址
  52. SHW_ADR("nb",nb);//显示栈中数据nb的地址
  54. free(b);//释放申请的空间，以避免内存泄露
  55. free(nb);
  56. }
  58. voidafunc(void)
  59. {
  60. staticintlevel=0;//初始化为0的静态数据存储在BSS段中
  62. intstack_var;//局部变量，存储在栈区
  64. if(++level==5)
  65. return;
  67. SHW_ADR("stack_varinstacksection",stack_var);
  68. SHW_ADR("levalinbsssection",level);
  70. afunc();
  71. }
  73. /*Output
  74. etextaddress:80488bfedataaddress:8049b48endaddress:8049b58
  75. Themainisataddress:80485be
  76. Theafuncisataddress:8048550
  78. bssLocatoin:
  79. Thebss_varisataddress:8049b54
  81. dataLocation:
  82. Thedata_varisataddress:8049b40
  84. StackLoation:
  85. Thestack_varinstacksectionisataddress:ff9cdf80
  86. Thelevelinbsssectionisataddress:8049b50
  87. Thestack_varinstacksectionisataddress:ff9cdf50
  88. Thelevelinbsssectionisataddress:8049b50
  89. Thestack_varinstacksectionisataddress:ff9cdf20
  90. Thelevelinbsssectionisataddress:8049b50
  91. Thestack_varinstacksectionisataddress:ff9cdef0
  92. Thelevelinbsssectionisataddress:8049b50
  94. Thestringpinstackstartisataddress:ff9cdf70
  95. Thestringpinstackendisataddress:ff9cdf90
  97. HeapLocation:
  98. Theallocatedheapstartisataddress:9020078
  99. Theallocatedheapendisataddress:90200c8
  101. p,bandnbinstack
  102. Thepisataddress:ff9cdfac
  103. Thebisataddress:ff9cdfa8
  104. Thenbisataddress:ff9cdfa4
  105. */


内存管理函数：
这里插入一段对void*的解释：
void*这不叫空指针,这叫无确切类型指针.这个指针指向一块内存,却没有告诉程序该用何种方式来解释这片内存.所以这种类型的指针不能直接进行取内容的操作.必须先转成别的类型的指针才可以把内容解释出来.

还有'

标签：#初始化#空间数据#char函数#堆栈#指针初始化#char#bss段 | 浏览：645 | 发布日期：

免责声明：内容来源于网络，仅用于学习参考。如对内容有疑问，请及时联系本站处理。

上篇JLINK、ULINK和STlink仿真器详解linux shell中读写操作mysql数据库下篇

宿迁高防，2C2G15M，22元/月；香港BGP，2C5G5M，25元/月 雨云优惠码：MjYwNzM=

相关文章

C++中清空缓冲区

C++中标准输入cin有多种输入方式。。 这篇文章罗列的还是简要易懂的。C++输入cin详解。。。如果只是简单的使用cin>>的话，会单个token的读入。但是会忽略换行符，空格，制表符等空白符。其中cin.getline()和cin.get()都会遇到一个非常棘手的事情，就是当输入的字符串，或者说缓冲区中的字符多于第二个参数int的要求时。缓...

servlet两种配置方法详解

1、web.xml中Servlet的注解 1 <servlet> 2 <!--servlet的内部名称，自定义 --> 3 <servlet-name>DemoAction</servlet-name> 4 <!--servlet的类全名：包名+类...

binary hacks读数笔记(readelf基本命令)

一、首先对readelf常用的参数进行简单说明： readelf命令是Linux下的分析ELF文件的命令，这个命令在分析ELF文件格式时非常有用，下面以ELF格式可执行文件test为例详细介绍： 1、readelf -v 显示版本 2、readelf -h 显示帮助 3、readelf -a test 显示test的全部信息 4、readelf -h te...

SpringBoot启动过程中涉及到了扩展接口

SpringApplicationRunListener接口 1、ApplicationListener接口 是ApplicationContext的事件监听器 2、EnvironmentPostProcessor接口 上下文环境后置处理器，事件中调用 3、PropertySourceLoader接口 自定义配置文件加载器，自己解析配置文件属性...

java之endwith()方法以及正则表达式匹配中文

今天写程序的时候遇到判断需要使用多个if(){}else{}语句，观察了一下需要判断的条件，发现判断的条件可以变为对条件最后几个汉字的判断，就想用正则表达式来对汉字判断，写完后，想到可以用Java中String类的endwith()方法来对汉字实现匹配，例如 String str="世界你好我喜欢编程"; if(str.endwith("编程")){ 　　...

（转载）uCOS-II的嵌入式串口通信模块设计

在嵌入式应用中，使用RTOS的主要原因是为了提高系统的可靠性，其次是提高开发效率、缩短开发周期。uCOS-II是一个占先式实时多任务内核，使用对象是嵌入式系统，对源代码适当裁减，很容易移植到8~32位不同框架的微处理器上。但uCOS-II仅是一个实时内核，它不像其他实时操作系统(如嵌入式Linux)那样提供给用户一些API函数接口。在uCOS-II实时内核...

最新文章

随机推荐

思享工具箱导航