内存分布，bss段/Data段/Text段/堆/栈

最新推荐文章于 2025-02-06 10:35:38 发布

sun5smile

最新推荐文章于 2025-02-06 10:35:38 发布

阅读量4.3k

点赞数 2

分类专栏： c

c 专栏收录该内容

17 篇文章

订阅专栏

http://blog.youkuaiyun.com/imdxt1986/article/details/7975911

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

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

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

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

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

一个程序本质上都是由 bss段、data段、text段三个组成的。

这样的概念，不知道最初来源于哪里的规定，但在当前的计算机程序设计中是很重要的一个基本概念。而且在嵌入式系统的设计中也非常重要，牵涉到嵌入式系统运行时的内存大小分配，存储单元占用空间大小的问题。

在采用段式内存管理的架构中（比如intel的80x86系统），bss段（Block Started by Symbol segment）通常是指用来存放程序中未初始化的全局变量的一块内存区域，一般在初始化时bss段部分将会清零。bss段属于静态内存分配，即程序一开始就将其清零了。

   比如，在C语言之类的程序编译完成之后，已初始化的全局变量保存在.data段中，未初始化的全局变量保存在.bss段中。
    在《Programming ground up》里对.bss的解释为：There is another section called the .bss. This section is like the data section, except that it doesn’t take up space in the executable.
    text和data段都在可执行文件中（在嵌入式系统里一般是固化在镜像文件中），由系统从可执行文件中加载；而bss段不在可执行文件中，由系统初始化。

http://blog.sina.com.cn/s/blog_7dc29ca00100usl1.html

一、C语言中的内存地址分配模型如

1、程序代码区:存放函数体的二进制代码。

2、全局区数据区：全局数据区划分为三个区域。全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。常量数据存放在另一个区域里。这些数据在程序结束后由系统释放。我们所说的BSS段(bsssegment)通常是指用来存放程序中未初始化的全局变量的一块内存区域。BSS是英文Block Started bySymbol的简称。

3、栈区:由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

4、堆区:一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。

5、命令行参数区:存放命令行参数和环境变量的值。
关于局部的字符串常量是存放在全局的常量区还是栈区，不同的编译器有不同的实现。可以通过汇编语言察看一下。不过vc环境下,局部常量就像局部变量一样存储于栈中，全局常量、字符常量存储于文字常量区。TC在常量区。

   在linux下:可以通过参数-c来编译生成汇编文件。如：
    gcc -c*.c
    gcc *.o -Maptest.txt -o test.elf
   用文本编辑器查看test.txt文件，你就看到那些bss段,data段,text段等信息了，但是没有堆栈段相关信息，用objdump命令查看.o文件的反汇编后的信息，或者用gcc-S *.c，查看各个.S文件就明白了。

C语言程序编译的内存分配：
1.栈区（stack）--编译器自动分配释放，主要存放函数的参数值，局部变量值等；
2.堆区（heap）--由程序员分配释放；
3.全局区或静态区 --存放全局变量和静态变量；程序结束时由系统释放，分为全局初始化区和全局未初始化区；
4.字符常量区 --常量字符串放与此，程序结束时由系统释放；
5.程序代码区
例：//main.c
int a=0; //全局初始化区
char *p1; //全局未初始化区
void main()
{
int b; //栈
char s[]="bb"; //栈
char *p2; //栈
char *p3="123"; //其中，“123\ 0”常量区，p3在栈区
static int c=0; //全局区
p1=(char*)malloc(10); //10个字节区域在堆区
strcpy(p1,"123"); //"123\0"在常量区，编译器可能会将它与p3所指向的"123"优化成一个地方。
}

堆与栈的区别

一、预备知识―程序的内存分配

一个由c/C++编译的程序占用的内存分为以下几个部分

1、栈区（stack）― 由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

2、堆区（heap）― 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。

3、全局区（静态区）（static）―，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放。

4、文字常量区 ―常量字符串就是放在这里的。程序结束后由系统释放

5、程序代码区―存放函数体的二进制代码。

二、例子程序

这是一个前辈写的，非常详细

//main.cpp

int a = 0;全局初始化区

char *p1;全局未初始化区

main()

{

int b;栈

char s[] = "abc"; 栈

char *p2; 栈

char *p3 = "123456";123456\0在常量区，p3在栈上。

static int c=0；全局（静态）初始化区

p1 = (char*)malloc(10);

p2 = (char *)malloc(20);

分配得来得10和20字节的区域就在堆区。

strcpy(p1, "123456");123456\0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。

}

二、堆和栈的理论知识

2.1申请方式

stack: 由系统自动分配。例如，声明在函数中一个局部变量 int b;系统自动在栈中为b开空间。

heap: 需要程序员自己申请，并指明大小，在c中malloc函数

如p1 = (char *)malloc(10);

在C++中用new运算符

如p2 = (char *)malloc(10);

但是注意p1、p2本身是在栈中的。

2.2 申请后系统的响应

栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。

堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。

2.3申请大小的限制

栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。

堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

2.4申请效率的比较：

栈由系统自动分配，速度较快。但程序员是无法控制的。堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活。

2.5堆和栈中的存储内容

栈：在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。

堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

2.6存取效率的比较

char s1[] = "aaaaaaaaaaaaaaa";

char *s2 = "bbbbbbbbbbbbbbbbb";

aaaaaaaaaaa是在运行时刻赋值的；而bbbbbbbbbbb是在编译时就确定的；但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。比如：

#include

void main()

{

char a = 1;

char c[] = "1234567890";

char *p ="1234567890";

a = c[1];

a = p[1];

return;

}

对应的汇编代码

10: a = c[1];

00401067 8A 4D F1 mov cl,byte ptr[ebp-0Fh]

0040106A 88 4D FC mov byte ptr[ebp-4],cl

11: a = p[1];

0040106D 8B 55 EC mov edx,dword ptr[ebp-14h]

00401070 8A 42 01 mov al,byte ptr[edx+1]

00401073 88 45 FC mov byte ptr[ebp-4],al

第一种在读取时直接就把字符串的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，在根据edx读取字符，显然慢了。

2.7小结：

堆和栈的区别可以用如下的比喻来看出：使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。

二、一个典型的C程序存储空间布局

一个典型的C程序存储空间布局由以下几个部分组成：

(正文段)： CPU执行的指令部分，也就是主要的程序代码编译出来的结果，只读，通常可以共享。

(初始化数据段)：通常称之为数据段，包含了程序中需要明确赋值的变量，譬如一些初始化的全局变量等，如int a = 10，变量名和值都存放在这个段中。

(未初始化数据段)：通常称之为BSS（BlockStarted by Symbol）段，包含了程序中没有进行赋值的变量，譬如一些未初始化的全局变量，如inta，在程序执行之前，内核会把这部分全部置为0（NULL）

(栈)：自动变量以及每次函数调用时所需保存的信息放在此段中。如函数调用时要保存返回地址等。栈是从上向下分配的。

(堆)：通常在堆中进行动态存储分配，如malloc,calloc, realloc等都从这里面分配。堆是从下向上分配的。

通常堆顶和栈底之间的虚拟地址空间是很大的。

对X86处理器上的Linux，正文段从0x08048000开始，栈底则从0xC0000000之下开始。

下图是一个典型的C程序存储空间的逻辑布局：

//main.c

int a = 0; 全局初始化区

char *p1; 全局未初始化区

main( )

{

intb; //栈

char s[] = "abc"; //栈

char *p2; //栈

char *p3 = "123456"; //123456\0在常量区，p3在栈上。

static int c =0； //全局（静态）初始化区

p1 = (char *)malloc(10);

p2 = (char *)malloc(20);//分配得来得10和20字节的区域就在堆区。

strcpy(p1, "123456"); //123456\0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。

}

三、c/c++语言中的内存分配──堆和栈的区别

基本知识

一、程序的内存分配
一个由c/C++编译的程序占用的内存分为以下几个部分
1、栈区（stack）：由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
2、堆区（heap）一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。
3、全局区（静态区）（static）：全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。– 程序结束后有系统释放
4、文字常量区：常量字符串就是放在这里的。程序结束后由系统释放
5、程序代码区：存放函数体的二进制代码。

如下面的一个例子：

//main.cpp

#include<string>
#include <iostream>
using namespace std;

int a = 0; //全局初始化区
char *p1; //全局未初始化区

main()
{
int b;// 栈
char s[] = "abc"; //栈
char *p2; //栈
char *p3 = "123456"; //123456\0在常量区，p3在栈上。
static int c = 0; //全局（静态）初始化区
p1 = (char *)malloc(10);
p2 = (char *)malloc(20);
//分配得来得10和20字节的区域就在堆区。
strcpy(p1, "123456");//123456\0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。

}

二、变量的存储方式可分为“静态存储”和“动态存储”两种。

静态存储变量通常是在变量定义时就分定存储单元并一直保持不变，直至整个程序结束。动态存储变量是在程序执行过程中，使用它时才分配存储单元，使用完毕立即释放。典型的例子是函数的形式参数，在函数定义时并不给形参分配存储单元，只是在函数被调用时，才予以分配，调用函数完毕立即释放。如果一个函数被多次调用，则反复地分配、释放形参变量的存储单元。

三、而变量存储类型是怎样与内存分配相对应的呢？

存储类型有以下四种：自动(auto)、静态(static)、外部(extern)、寄存器(register)。变量说明的完整形式应为：存储类型说明符数据类型说明符变量名，变量名…；例如：static int a,b; 说明a,b为静态类型变量
auto char c1,c2; 说明c1,c2为自动字符变量
static int a[5]={1,2,3,4,5}; 说明a为静整型数组
extern int x,y; 说明x,y为外部整型变量

auto和register存储类型的变量属于动态存储方式，而static和extern的变量属于静态存储方式。

static变量放在内存中的全局区（静态区），在程序一开始就为这个变量分配内存空间。全局静态变量在全局可见，局部的静态变量在局部可见，但在程序执行过程中一直驻留内存。

static inta=0; //全局静态变量

    voidfoo()
    {
      static int v=0;//局部静态变量

…
}

auto变量是自动存储类型，每次执行到定义该变量的语句块时，都将会为该变量在内存中产生一个新的拷

char *d; //全局未初始化区
static int c = 12;

void foo(int foo1)
{
const char *foo2 = "abcsf";
static int foo3 = 12;
cout << " foo2:"<< foo2<< " foo3:"<< foo3<< endl;
}
main()
{
inte; // 栈

char f[] ="abc";                       // "abc"在常量区,f[]在栈上
char*g;                                  //栈
char *h ="123456";                   //123456\12在常量区，h在栈上。
static int i =12;                        //全局（静态）初始化区
extern int j;
register int k = 12;
int *l = new int(12);//放在堆上
d = new char[112];
strcpy(d,h);                            //123456\12放在常量区，编译器可能会将它与p3

//所指向的"123456"优化成一个地方。
g=h;
e=1;
foo(12);
cout << "a:"<< a<< " b:"<< b
<< " c:"<< c<< " d:"<< d
<< " e:"<< e<< " f:"<< f
<< " g:"<< g<< " h:"<< h
<< " i:"<< i<< " j:"<< j
<< " k:"<< k<< " l:"<< *l
<<endl; //防止编译器优化
delete l;
delete [] d;
}

//foo1.cpp

static int j = 12;
static float b = 1.0F;

用"gcc -Sfoo.cpp foo2.cpp"命令生成汇编代码foo.s,foo1.s，观察每一段代码的对应汇编程序。首先看foo1.cpp编译后结果：

.file "foo1.cpp"

.globl_j 全局变量
.data 说明以下的定义是放在数据段上的，也即放在全局区（静态区）

（static）上
.align4 确保指令会在字（word）的边缘开始，如果j是double型的将

                           为.align 8
_j:                       j是foo.cpp文件中声明的外部变量，在foo1.cpp中是静态变量
.long12               j的值为12

.globl _j
.align 4
_b:
.long 1065353216 b的值为1，为什么是这个数需要看浮点数的表示方法，如果b设为

double型，则这里需要分两步设置.long 0 .long 1072693248

然后再看foo.cpp里面的内容吧：非静态变量a的定义与静态变量c的定义基本是一样的有一点不同就是a的定义加入了一句.globl_a，表明这个变量是全局变量，而在文件中的static变量则没有声明为全局变量。则变量的作用域只限于本文件

.globl _a
.data
.align 4
_a:
.long 12

.data
.align 4
_c:
.long 12

而对于未初始化的变量d，则声明如下

.globl _d
.globl _d
.bss 说明以下的定义是放在未初始化的全局区（静态区）（static）上
.align 4
_d:
.space4 只分配大小为4的空间（指针有4个字）节，但并没有给这个变量赋值

与我们预想的情况一样，这里并没有对extern变量的声明，因为我们只要拿来用就可以了，当将两个程序链接的时候会将几个文件的data段，bss段，text段等等连接到一起，这时候就可以找到没有声明的变量了。

下面还有一段关于foo3的定义。这说明编译器将所有static变量都放在data段，而局部static变量则给他起一些奇怪的名字（带有这个变量的作用域等信息）_ZZ3fooiE4foo3，来限定他们的作用域，这样局部的static变量就只能在局部作用域中被访问了。

.align 4
_ZZ3fooiE4foo3:
.long 12

接下来是text段，记录了一组常数变量。这是在foo函数中用到的常量，编译器实际上会找到本段代码中的常量然后将其放在一起。

.text
LC0:
.ascii "abcsf\0"
LC1:
.ascii " foo2:\0"
LC2:
.ascii " foo3:\0"

下面进入foo函数的代码段。下面代码的意思为将当前基栈地址入栈，然后将栈顶地址（esp）存入栈底寄存器（ebp）（注意，因为栈的结构是往小地址扩展的，大地址为栈底，小地址为栈顶），将当前栈顶自减24，所以当前栈内的空间就为24，在24个字节的空间中有4个字节的const char*型的foo2。为什么要分配24个字节？这与编译器的设置有关，gcc编译器默认的最小栈空间大小是24字节。

.globl __Z3fooi
.def __Z3fooi; .scl 2; .type 32; .endef
__Z3fooi:
LFB1:
pushl �p
LCFI0:
movl %esp, �p
LCFI1:
subl $24, %esp

下面一句话将LC0放入ebp-4的地址中（即栈底基地址-4），这里就可以发现常量数据不可更改的性质实际上是由编译器来决定的，当形成汇编语言之后常量型数据和局部变量就没有什么区别了，即函数中代码int a =10; 与 const int b = 10;的编译结果都是一样的，不同的是当在本代码块中改变b时编译通不过而已。

movl $LC0, -4(�p)

下面的几行代码比较难理解，将一个东西放到栈顶，然后将LC1（要输出的第一个字符串）放到栈顶朝栈底方向+4个地址的位置，然后调用一个函数。可以想象这个函数要用到esp地址与esp+4地址中的变量，这可能是cout的一个机制。

movl $__ZSt4cout, (%esp)
movl $LC1, 4(%esp)
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc

接着将eax值放入esp，这是cout函数的返回值，这句话与movl $__ZSt4cout, (%esp)
首次用cout的作用是一样的，返回一个流可以继续 <<（ C++primer里面有详细的说明）不用理他。再将ebp-4地址中的变量（foo2）放入esp+4，由于栈寄存器不能直接赋值所以用了一下eax，然后调用同样的函数。
movl �x, (%esp)
movl -4(�p), �x
movl �x, 4(%esp)
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc

下面的代码同理，不详述。

movl �x, (%esp)
movl $LC2, 4(%esp)
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
movl �x, (%esp)
movl _ZZ3fooiE4foo3, �x
movl �x, 4(%esp)
call __ZNSolsEi
movl �x, (%esp)
movl $__ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_,4(%esp)
call __ZNSolsEPFRSoS_E
leave
ret

我们的话题有点偏离主题了，现在在重新回到内存分配的主题。下面又是一个很大的text段，编译器将本段内的字符串常量都放在这里了

.text
LC3:
.ascii "abc\0"
LC4:
.ascii "123456\0"
LC5:
.ascii " a:\0"
LC6:
.ascii " b:\0"
LC7:
.ascii " c:\0"
LC8:
.ascii " d:\0"
LC9:
.ascii " e:\0"
LC10:
.ascii " f:\0"
LC11:
.ascii " g:\0"
LC12:
.ascii " h:\0"
LC13:
.ascii " i:\0"
LC14:
.ascii " j:\0"
LC15:
.ascii " k:\0"
LC16:
.ascii " l:\0"

同样，下面的代码将函数块中的static变量放入data块中。

.data
.align 4
_ZZ4mainE1i:
.long 12

分配40个字节的栈空间。

_main:
LFB2:
pushl �p
LCFI3:
movl %esp, �p
LCFI4:
subl $40, %esp

下面的代码是gcc编译器的new的过程，new的过程需要12个字节的栈空间。总之，我们知道new的东西没有放在栈上，只将返回的指针放在栈上。

movl $4,(%esp)                new一个int所以是4个字节
call__Znwj                  new空间时调用的函数
movl �x, -28(�p)   返回的地址赋给l
movl -28(�p), �x
movl $12,(�x)              12赋值给这个地址，以下可能是在检验是否出错
movb $0, %al
movl -28(�p), �x
movl �x, -20(�p)
testb %al, %al
je L10
movl -28(�p), �x
movl �x, (%esp)
call __ZdlPv