c/c++中内存区域划分大总结

一. 在c中分为这几个存储区

1.代码区- 存放程序的执行代码(机器指令）

2.栈区- 由编译器自动分配释放

3.堆区 - 通常由程序员分配释放，若程序员不释放，程序结束时可能由OS回收

4.全局区(静态区)和常量区，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另外一块区域。其中还有一个专门放常量的地方- 程序结束释放

在函数体中定义的变量一般是在栈上，用malloc, calloc, realloc等分配内存的函数分配获得的就是在堆上。在全部函数体外定义的是全局量，加了static修饰符后无论在哪里都存放在全局区（静态区）,在全部函数体外定义的static变量表示在该文件中有效，不能extern到别的文件用，在函数体内定义的static表示只在该函数体内有效。另外，函数中的"adgfdf"这样的字符串存放在常量区。好比：

int a = 0; //全局初始化区

char *p1; //全局未初始化区

void main()

{

    int b; //栈

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

    char *p2; //栈

    char *p3 = "123456"; //123456{post.content}在常量区，p3在栈上

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

    p1 = (char *)malloc(10); //分配得来得10字节的区域在堆区

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

    strcpy(p1, "123456");

    //123456{post.content}放在常量区，编译器可能会将它与p3所指向的"123456"优化成一块

}

二.在C++中，内存分红5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区

1.代码区，主要是可执行程序，汇编代码或机器指令。

2.栈区，就是那些由编译器在须要的时候分配，在不须要的时候自动清楚的变量的存储区。里面的变量一般是局部变量、函数参数等。

3.堆区(或自由存储区)，就是那些由new分配的内存块，他们的释放编译器不去管，由咱们的应用程序去控制，通常一个new就要对应一个delete。若是程序员没有释放掉，那么在程序结束后，操做系统会自动回收。或者是那些由malloc等分配的内存块，他和堆是十分类似的，不过它是用free来结束本身的生命的。

4.全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在之前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。

5.常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不容许修改（固然，你要经过非正当手段也能够修改）

三. 谈谈堆与栈的关系与区别

具体地说，现代计算机(串行执行机制)，都直接在代码底层支持栈的数据结构。这体如今，有专门的寄存器指向栈所在的地址，有专门的机器指令完成数据入栈出栈的操做。这种机制的特色是效率高，支持的数据有限，通常是整数，指针，浮点数等系统直接支持的数据类型，并不直接支持其余的数据结构。由于栈的这种特色，对栈的使用在程序中是很是频繁的。对子程序的调用就是直接利用栈完成的。机器的call指令里隐含了把返回地址推入栈，而后跳转至子程序地址的操做，而子程序中的ret指令则隐含从堆栈中弹出返回地址并跳转之的操做。C/C++中的自动变量是直接利用栈的例子，这也就是为何当函数返回时，该函数的自动变量自动失效的缘由。

和栈不一样，堆的数据结构并非由系统(不管是机器系统仍是操做系统)支持的，而是由函数库提供的。基本的malloc/realloc/free 函数维护了一套内部的堆数据结构。当程序使用这些函数去得到新的内存空间时，这套函数首先试图从内部堆中寻找可用的内存空间，若是没有可使用的内存空间，则试图利用系统调用来动态增长程序数据段的内存大小，新分配获得的空间首先被组织进内部堆中去，而后再以适当的形式返回给调用者。当程序释放分配的内存空间时，这片内存空间被返回内部堆结构中，可能会被适当的处理(好比和其余空闲空间合并成更大的空闲空间)，以更适合下一次内存分配申请。这套复杂的分配机制实际上至关于一个内存分配的缓冲池(Cache)，使用这套机制有以下若干缘由：

1. 系统调用可能不支持任意大小的内存分配。有些系统的系统调用只支持固定大小及其倍数的内存请求(按页分配)；这样的话对于大量的小内存分类来讲会形成浪费。

2. 系统调用申请内存多是代价昂贵的。系统调用可能涉及用户态和核心态的转换。

3. 没有管理的内存分配在大量复杂内存的分配释放操做下很容易形成内存碎片。

堆和栈的对比

从以上知识可知，栈是系统提供的功能，特色是快速高效，缺点是有限制，数据不灵活；而栈是函数库提供的功能，特色是灵活方便，数据适应面普遍，可是效率有必定下降。栈是系统数据结构，对于进程/线程是惟一的；堆是函数库内部数据结构，不必定惟一。不一样堆分配的内存没法互相操做。栈空间分静态分配和动态分配两种。静态分配是编译器完成的，好比自动变量(auto)的分配。动态分配由alloca函数完成。栈的动态分配无需释放(是自动的)，也就没有释放函数。为可移植的程序起见，栈的动态分配操做是不被鼓励的！堆空间的分配老是动态的，虽然程序结束时全部的数据空间都会被释放回系统，可是精确的申请内存/ 释放内存匹配是良好程序的基本要素。

    1.碎片问题：对于堆来说，频繁的new/delete势必会形成内存空间的不连续，从而形成大量的碎片，使程序效率下降。对于栈来说，则不会存在这个问题，由于栈是先进后出的队列，他们是如此的一一对应，以致于永远都不可能有一个内存块从栈中间弹出，在他弹出以前，在他上面的后进的栈内容已经被弹出，详细的能够>参考数据结构，这里咱们就再也不一一讨论了。

    2.生长方向：对于堆来说，生长方向是向上的，也就是向着内存地址增长的方向；对于栈来说，它的生长方向是向下的，是向着内存地址减少的方向增加。

    3.分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，好比局部变量的分配。动态分配由alloca函数进行分配，可是栈的动态分配和堆是不一样的，他的动态分配是由编译器进行释放，无需咱们手工实现。

    4.分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照必定的算法（具体的算法能够参考数据结构/操做系统）在堆内存中搜索可用的足够大小的空间，若是没有足够大小的空间（多是因为内存碎片太多），就有可能调用系统功能去增长程序数据段的内存空间，这样就有机会分到足够大小的内存，而后进行返回。显然，堆的效率比栈要低得多。

    明确区分堆与栈:

    在bbs上，堆与栈的区分问题，彷佛是一个永恒的话题，因而可知，初学者对此每每是混淆不清的，因此我决定拿他第一个开刀。

    首先，咱们举一个例子：

void f()

{

    int* p=new int[5];

}

这条短短的一句话就包含了堆与栈，看到new，咱们首先就应该想到，咱们分配了一块堆内存，那么指针p呢？他分配的是一块栈内存，因此这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p。在程序会先肯定在堆中分配内存的大小，而后调用operator new分配内存，而后返回这块内存的首地址，放入栈中，他在VC6下的汇编代码以下：

    00401028    push         14h

    0040102A    call            operator new (00401060)

    0040102F    add           esp,4

    00401032    mov          dword ptr [ebp-8],eax

    00401035    mov          eax,dword ptr [ebp-8]

    00401038    mov          dword ptr [ebp-4],eax

    这里，咱们为了简单并无释放内存，那么该怎么去释放呢？是delete p么？澳，错了，应该是delete []p，这是为了告诉编译器：我删除的是一个数组，VC6就会根据相应的Cookie信息去进行释放内存的工做。

    好了，咱们回到咱们的主题：堆和栈究竟有什么区别？

    主要的区别由如下几点：

    一、管理方式不一样；

    二、空间大小不一样；

    三、可否产生碎片不一样；

    四、生长方向不一样；

    五、分配方式不一样；

    六、分配效率不一样；

    管理方式：对于栈来说，是由编译器自动管理，无需咱们手工控制；对于堆来讲，释放工做由程序员控制，容易产生memory leak。

    空间大小：通常来说在32位系统下，堆内存能够达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的。可是对于栈来说，通常都是有必定的空间大小的，例如，在VC6下面，默认的栈空间大小是1M（好像是，记不清楚了）。固然，咱们能够修改：

    打开工程，依次操做菜单以下：Project->Setting->Link，在Category 中选中Output，而后在Reserve中设定堆栈的最大值和commit。

注意：reserve最小值为4Byte；commit是保留在虚拟内存的页文件里面，它设置的较大会使栈开辟较大的值，可能增长内存的开销和启动时间。

    堆和栈相比，因为大量new/delete的使用，容易形成大量的内存碎片；因为没有专门的系统支持，效率很低；因为可能引起用户态和核心态的切换，内存的申请，代价变得更加昂贵。因此栈在程序中是应用最普遍的，就算是函数的调用也利用栈去完成，函数调用过程当中的参数，返回地址，EBP和局部变量都采用栈的方式存放。因此，咱们推荐你们尽可能用栈，而不是用堆。

另外对存取效率的比较:

代码:

char s1[] = "aaaaaaaaaaaaaaa";

char *s2 = "bbbbbbbbbbbbbbbbb";

aaaaaaaaaaa是在运行时刻赋值的；

而bbbbbbbbbbb是在编译时就肯定的；

可是，在之后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。

好比：

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读取字符，显然慢了.

    不管是堆仍是栈，都要防止越界现象的发生（除非你是故意使其越界），由于越界的结果要么是程序崩溃，要么是摧毁程序的堆、栈结构，产生以想不到的结果,就算是在你的程序运行过程当中，没有发生上面的问题，你仍是要当心，说不定何时就崩掉,编写稳定安全的代码才是最重要的。

static用来控制变量的存储方式和可见性

       函数内部定义的变量，在程序执行到它的定义处时，编译器为它在栈上分配空间，函数在栈上分配的空间在此函数执行结束时会释放掉，这样就产生了一个问题: 若是想将函数中此变量的值保存至下一次调用时，如何实现？ 最容易想到的方法是定义一个全局的变量，但定义为一个全局变量有许多缺点，最明显的缺点是破坏了此变量的访问范围（使得在此函数中定义的变量，不只仅受此 函数控制）。

       须要一个数据对象为整个类而非某个对象服务,同时又力求不破坏类的封装性,即要求此成员隐藏在类的内部，对外不可见。

       static的内部机制：

       静态数据成员要在程序一开始运行时就必须存在。由于函数在程序运行中被调用，因此静态数据成员不能在任何函数内分配空间和初始化。

       这样，它的空间分配有三个可能的地方，一是做为类的外部接口的头文件，那里有类声明；二是类定义的内部实现，那里有类的成员函数定义；三是应用程序的main（）函数前的全局数据声明和定义处。

      静态数据成员要实际地分配空间，故不能在类的声明中定义（只能声明数据成员）。类声明只声明一个类的“尺寸和规格”，并不进行实际的内存分配，因此在类声 明中写成定义是错误的。它也不能在头文件中类声明的外部定义，由于那会形成在多个使用该类的源文件中，对其重复定义。

      static被引入以告知编译器，将变量存储在程序的静态存储区而非栈上空间，静态数据成员按定义出现的前后顺序依次初始化，注意静态成员嵌套时，要保证所嵌套的成员已经初始化了。消除时的顺序是初始化的反顺序。

       static的优点：

       能够节省内存，由于它是全部对象所公有的，所以，对多个对象来讲，静态数据成员只存储一处，供全部对象共用。静态数据成员的值对每一个对象都是同样，但它的 值是能够更新的。只要对静态数据成员的值更新一次，保证全部对象存取更新后的相同的值，这样能够提升时间效率。

        引用静态数据成员时，采用以下格式：

         <类名>::<静态成员名>

    若是静态数据成员的访问权限容许的话(即public的成员)，可在程序中，按上述格式

来引用静态数据成员。

       PS:

      (1)类的静态成员函数是属于整个类而非类的对象，因此它没有this指针，这就致使

了它仅能访问类的静态数据和静态成员函数。

      (2)不能将静态成员函数定义为虚函数。

      (3)因为静态成员声明于类中，操做于其外，因此对其取地址操做，就多少有些特殊

，变量地址是指向其数据类型的指针 ，函数地址类型是一个“nonmember函数指针”。

      (4)因为静态成员函数没有this指针，因此就差很少等同于nonmember函数，结果就

产生了一个意想不到的好处：成为一个callback函数，使得咱们得以将C++和C-based X W

indow系统结合，同时也成功的应用于线程函数身上。

      (5)static并无增长程序的时空开销，相反她还缩短了子类对父类静态成员的访问

时间，节省了子类的内存空间。

      (6)静态数据成员在<定义或说明>时前面加关键字static。

      (7)静态数据成员是静态存储的，因此必须对它进行初始化。

      (8)静态成员初始化与通常数据成员初始化不一样:

      初始化在类体外进行，而前面不加static，以避免与通常静态变量或对象相混淆；

      初始化时不加该成员的访问权限控制符private，public等；

           初始化时使用做用域运算符来标明它所属类；

           因此咱们得出静态数据成员初始化的格式：

         <数据类型><类名>::<静态数据成员名>=<值>

      (9)为了防止父类的影响，能够在子类定义一个与父类相同的静态变量，以屏蔽父类的影响。这里有一点须要注意：咱们说静态成员为父类和子类共享，但咱们有 重复定义了静态成员，这会不会引发错误呢？不会，咱们的编译器采用了一种绝妙的手法：name-mangling 用以生成惟一的标志。

补充：new  delete［］,基本类型的对象没有析构函数（例如 int , char ），因此回收基本类型组成的数组空间 delete  delete[] 都是应该能够如： int p = new int[10], delete p 和delete[]p 均可 。可是对于类对象数组（如string strArr = new string[10]），只能 delete[]。对 new 的单个对象，只能 delete 不能 delete[] 回收空间 。