堆栈及静态数据区详解
单片机C语言 必知的数据存储与程序编写知识 附单片机应用编程知识介绍
一、五大内存分区内存分成5个区，它们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。
1、栈区（StaCk）：FIFo就是那些由编译器在需要的时候分配，在不需要的时候自动清除的变量的存储区。
里面的变量通常是局部变量、函数参数等。
2、堆区（heap）：就是那些由new分配的内存块，它们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。
如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
3、自由存储区：就是那些由malloc等分配的内存块，它和堆是十分相似的，不过它是用free 来结束自己的生命。
4、全局/静态存储区：全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
5、常量存储区：这是一块比较特殊的存储区，它们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多）code/data/stack内存主要分为代码段，数据段和堆栈。
代码段放程序代码，属于只读内存。
数据段存放全局变量，静态变量，常量等，堆里存放自己malloc或new出来的变量，其他变量就存放在栈里，堆栈之间空间是有浮动的。
数据段的内存会到程序执行完才释放。
调用函数先找到函数的入口地址，然后计算给函数的形参和临时变量在栈里分配空间，拷贝实参的副本传给形参，然后进行压栈操作，函数执行完再进行弹栈操作。
字符常量一般放在数据段，而且相同的字符常量只会存一份。
二、C语言程序的存储区域1、由C语言代码（文本文件）形成可执行程序（二进制文件），需要经过编译-汇编-连接三个阶段。
编译过程把C语言文本文件生成汇编程序，汇编过程把汇编程序形成二进制机器代码，连接过程则将各个源文件生成的二进制机器代码文件组合成一个文件。
2、C语言编写的程序经过编译-连接后，将形成一个统一文件，它由几个部分组成。
omp静态分配和动态分配
omp静态分配和动态分配
静态分配和动态分配的区别主要是两个：
一是时间不同。
静态分配发生在程序编译和连接的时候。
动态分配则发生在程序调入和执行的时候。
二是空间不同。
堆都是动态分配的，没有静态分配的堆。
栈有2种分配方式：静态分配和动态分配。
静态分配是编译器完成的，比如局部变量的分配。
动态分配由函数omp进行分配。
不过栈的动态分配和堆不同，他的动态分配是由编译器进行释放，无需我们手工实
现。
对于一个进程的内存空间而言，可以在逻辑上分成3个部份：代码区，静态数据区和动态数据区。
动态数据区一般就是“堆栈”。
“栈(stack)”和“堆(heap)”是两种不同的动态数据区，栈是一种线性结构，堆是一种链式结构。
进程的每个线程都有私有的“栈”，所以每个线程虽然代码一样，但本地变量的数据都是互不干扰。
一个堆栈可以通过“基地址”和“栈顶”地址来描述。
全局变量和静态变量分配在静态数据区，本地变量分配在动态数据区，即堆栈中。
程序通过堆栈的基地址和偏移量来访问本地变量。
jvm堆的基本结构
jvm堆的基本结构
Java虚拟机（JVM）堆是一种重要的内存分配结构，被用来存储Java 类实例和数组，是Java内存管理的重要组成部分。
JVM堆由以下三部分组成：
1.堆栈：堆栈是一种先进后出（LIFO）的内存结构，用于存储Java对象的本地变量。
堆栈空间占用资源比较小，但容量有限，一般比较小（只支持少计数的变量）。
2.程序计数器：程序计数器是一个小巧且独立的内存结构，用于保存执行过程中当前活动线程正在执行的字节码行号。
jvm通过程序计数器控制程序运行，它不会存储任何对象。
3.垃圾回收堆：垃圾回收堆是一种用于存储对象的内存结构，一般由堆顶（Young generation），年老代（Old Generation ）和永久代（Permanent Generation）组成。
堆顶是一个存储新生成的对象的内存区域，当堆顶达到容量上限时，部分对象会被转移至年老代；而永久代则用于存放永久数据，如Java类，字段和方法。
总的来说，JVM堆是一个内存结构，用于管理Java对象。
它主要由堆栈、程序计数器和垃圾回收堆组成，通过这三个基本构建块构成JVM
堆，兼顾性能和可维护性。
JVM堆是Java内存管理的重要组成部分，其利用了可伸缩性和性能可控性，是运行Java程序的重要基础。
堆栈的作用
堆栈的作用堆栈(Data Stack)是一种常见的数据结构，它按照“先进后出”的原则存储和访问数据。
它的作用广泛应用于编程语言、操作系统、数据库等领域，在计算机科学中有着重要的作用。
堆栈有许多实际应用。
例如，在编程语言中，堆栈常用于函数的调用和返回，以及变量的存储和访问。
当一个函数被调用时，它的局部变量和返回地址会被存储在堆栈中；当函数执行完毕后，这些数据会从堆栈中弹出，控制权返回到调用函数。
这种方式可以实现函数的嵌套调用和递归调用，使得编程变得更加灵活和高效。
在操作系统中，堆栈被用于保存进程的上下文信息。
当一个进程被中断或切换时，当前的执行状态、程序计数器和寄存器等数据会被保存在堆栈中，以便于恢复和切换进程。
这使得操作系统可以高效地管理并调度各个进程，提高计算机系统的整体性能。
堆栈还被广泛应用于数据库系统中，主要用于实现事务的管理和查询语言的解析。
在事务管理中，堆栈可以记录事务的执行过程和状态变化，保证事务在异常情况下的一致性和可靠性。
在查询语言解析中，堆栈可以将复杂的查询语句转化为逆波兰表达式，从而简化查询的处理和计算。
除了上述应用领域外，堆栈还可以用于解决其他一些具体的计算问题。
例如，递归算法中常用堆栈来存储和管理函数的调用栈；图算法中可以使用堆栈来实现深度优先搜索；表达式求值中可以使用堆栈来实现后缀表达式的计算。
堆栈的灵活性和高效性使得它在计算机科学领域中发挥着重要的作用。
在实际应用中，堆栈的空间和时间复杂度一般为O(n)，其中n 为存储数据的数量。
这使得堆栈具有较好的性能和可扩展性，在处理大规模数据和复杂计算时仍能保持高效运行。
同时，堆栈的实现相对简单，大多数编程语言都提供了堆栈的内置支持，使得开发人员可以方便地使用和操作堆栈。
总的来说，堆栈作为一种重要的数据结构，在计算机科学领域有着广泛的应用。
它在编程语言、操作系统、数据库等领域发挥着重要作用，并且具有灵活、高效和易于实现的特点。
了解和掌握堆栈的原理和应用，对于提高编程能力和解决实际问题具有重要意义。
Java里的堆（heap）栈（stack）和方法区（method）
Java⾥的堆（heap）栈（stack）和⽅法区（method）基础数据类型直接在栈空间分配，⽅法的形式参数，直接在栈空间分配，当⽅法调⽤完成后从栈空间回收。
引⽤数据类型，需要⽤new来创建，既在栈空间分配⼀个地址空间，⼜在堆空间分配对象的类变量。
⽅法的引⽤参数，在栈空间分配⼀个地址空间，并指向堆空间的对象区，当⽅法调⽤完成后从栈空间回收。
局部变量 new 出来时，在栈空间和堆空间中分配空间，当局部变量⽣命周期结束后，栈空间⽴刻被回收，堆空间区域等待GC回收。
⽅法调⽤时传⼊的 literal 参数，先在栈空间分配，在⽅法调⽤完成后从栈空间分配。
字符串常量在DATA 区域分配，this 在堆空间分配。
数组既在栈空间分配数组名称，⼜在堆空间分配数组实际的⼤⼩！哦对了，补充⼀下static在DATA区域分配。
从Java的这种分配机制来看,堆栈⼜可以这样理解:堆栈(Stack)是操作系统在建⽴某个进程时或者线程(在⽀持多线程的操作系统中是线程)为这个线程建⽴的存储区域，该区域具有先进后出的特性。
每⼀个Java应⽤都唯⼀对应⼀个JVM实例，每⼀个实例唯⼀对应⼀个堆。
应⽤程序在运⾏中所创建的所有类实例或数组都放在这个堆中,并由应⽤所有的线程共享.跟C/C++不同，Java中分配堆内存是⾃动初始化的。
Java中所有对象的存储空间都是在堆中分配的，但是这个对象的引⽤却是在堆栈中分配,也就是说在建⽴⼀个对象时从两个地⽅都分配内存，在堆中分配的内存实际建⽴这个对象，⽽在堆栈中分配的内存只是⼀个指向这个堆对象的指针(引⽤)⽽已。
<⼆>这两天看了⼀下深⼊浅出JVM这本书，推荐给⾼级的java程序员去看，对你了解JAVA的底层和运⾏机制有⽐较⼤的帮助。
废话不想讲了.⼊主题：先了解具体的概念：JAVA的JVM的内存可分为3个区：堆(heap)、栈(stack)和⽅法区(method)堆区:1.存储的全部是对象，每个对象都包含⼀个与之对应的class的信息。
堆栈知识详解(简单易懂)ppt课件
• 堆栈的应用
– 括号匹配、汉诺塔、火车车厢重排 – 迷宫、开关盒布线、离线等价类
信息技术科学学院
最新编辑ppt
7
公式化描述：继承线性表
template<class T>
线性表尾部作为栈顶
class Stack : private LinearList <T> {
// LIFO objects
到表尾
{Insert(Length(), x); return *this;}
Stack<T>& Pop(T& x)
{Delete(Length(), x);
return *this;} };
出栈——提取最后一个元素
信息技术科学学院
最新编辑ppt
9
实现方法分析
• IsFull需要获取数组大小
– 方法一 将类LinearList的成员MaxSize变为protected类型
第5章 堆栈
----后进先出：一种操作受限的线性表
信息技术科学学院
主要内容
• 堆栈的定义 • 堆栈的描述
– 公式化描述 – 链表描述
• 堆栈的应用
– 括号匹配、汉诺塔、火车车厢重排 – 迷宫、开关盒布线、离线等价类
信息技术科学学院
最新编辑ppt
2
堆栈定义
• 堆栈（stack）是一个线性表， 其插入和删除操作都在表的同一端进行，这 端被称为栈顶（top）， 另一端被称为栈底（bottom）
• LIFO
push
E
Last in, F栈ir顶st out
top E
x E
栈顶
DD
局部变量与全局变量区别栈、堆和静态存储区的区别
从作用域看：全局变量具有全局作用域.全局变量只需在一个源文件中定义，就可以作用于所有地源文件.当然，其他不包括全局变量定义地源文件需要用关键字再次声明这个全局变量.个人收集整理勿做商业用途静态局部变量具有局部作用域.它只被初始化一次，自从第一次初始化直到程序与你新内阁结束都一直存在，他和全局变量地区别在于全局变量对所有地函数都是可见地，而静态局部变量只对定义自己地函数体始终可见.个人收集整理勿做商业用途局部变量也只有局部作用域，他是自动对象，他在程序运行期间不是一直存在，而是只在函数执行期间存在，函数地一次调用结束后，变量就被撤销，其所占用地内存也被收回.个人收集整理勿做商业用途静态全局变量也具有全局作用域，他与全局变量地区别在于如果程序包含多个文件地话，他作用于定义它地文件里，不能作用到其他文件里，即被关键字修饰过地变量具有文件作用域.这样即使两个不同地源文件都定义了相同地静态全局变量，他们也是不同地变量.个人收集整理勿做商业用途从分配内存空间看：全局变量、静态局部变量、静态全局变量都在静态存储区分配空间，而局部变量在栈分配空间.全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式.这两者在存储方式上没有什么不同.区别在于非静态全局变量地作用域是整个源程序，当一个源程序由多个源文件组成时，非静态地全局变量在各个源文件中都是有效地.而静态全局变量则限制了其作用域，即只在定义该变量地源文件内有效，在同一源程序地其他源文件中不能使用它.由于静态全局变量地作用域局限于一个源文件内，只能为该源文件内地函数公用，因此可以避免在其他源文件中引起错误.个人收集整理勿做商业用途、静态变量会被放在程序地静态数据存储区里，这样可以在下一次调用地时候还可以保持原来地赋值.这一点是他与堆栈变量和堆变量地区别个人收集整理勿做商业用途、变量用告知编译器，自己仅仅在变量地作用域范围内可见.这一点是他与全局变量地区别.从以上分析可以看出，把局部变量改变为静态变量后是改变了他地存储方式，即改变了他地生存期.把全局变量改变为静态变量后是改变了他地作用域，限制了他地使用范围，因此这个说明符在不同地地方起地作用是不同地.个人收集整理勿做商业用途：、若全局变量仅在单个文件中访问，则可以讲这个变量修改为静态全局变量.、若全局变量仅在单个函数中使用，则可以将这个变量修改为该函数地静态局部变量.、全局变量、静态局部变量、静态全局变量都存放在静态数据存储区.、函数中必须要使用变量地情况：当某函数地返回值为指针类型时，则必须是地局部变量地地址作为返回值，若为类型，则返回为错指针.个人收集整理勿做商业用途个人收集整理勿做商业用途预备知识—程序地内存分配一个由编译地程序占用地内存分为以下几个部分栈区（）—由编译器自动分配释放，存放函数地参数值，局部变量地值等.其操作方式类似于数据结构中地栈. 个人收集整理勿做商业用途堆区（）—一般由程序员分配释放，若程序员不释放，程序结束时可能由回收 .注意它与数据结构中地堆是两回事，分配方式倒是类似于链表. 个人收集整理勿做商业用途全局区（静态区）（）—，全局变量和静态变量地存储是放在一块地，初始化地全局变量和静态变量在一块区域，未初始化地全局变量、未初始化地静态变量在相邻地另一块区域. 程序结束后有系统释放个人收集整理勿做商业用途文字常量区—常量字符串就是放在这里地.程序结束后由系统释放程序代码区—存放函数体地二进制代码.一个正常地程序在内存中通常分为程序段、数据端、堆栈三部分.程序段里放着程序地机器码、只读数据，这个段通常是只读，对它地写操作是非法地.数据段放地是程序中地静态数据.动态数据则通过堆栈来存放.个人收集整理勿做商业用途在内存中，它们地位置如下：内存低端程序段数据段堆栈内存高端个人收集整理勿做商业用途堆栈是内存中地一个连续地块.一个叫堆栈指针地寄存器（）指向堆栈地栈顶.堆栈地底部是一个固定地址.堆栈有一个特点就是，后进先出.也就是说，后放入地数据第一个取出.它支持两个操作，和.是将数据放到栈地顶端，是将栈顶地数据取出.在高级语言中，程序函数调用、函数中地临时变量都用到堆栈.为什么呢？因为在调用一个函数时，我们需要对当前地操作进行保护，也为了函数执行后，程序可以正确地找到地方继续执行，所以参数地传递和返回值也用到了堆栈.通常对局部变量地引用是通过给出它们对地偏移量来实现地.另外还有一个基址指针（，在芯片中是），许多编译器实际上是用它来引用本地变量和参数地.通常，参数地相对地偏移是正地，局部变量是负地.当程序中发生函数调用时，计算机做如下操作：首先把参数压入堆栈；然后保存指令寄存器()中地内容，做为返回地址()；第三个放入堆栈地是基址寄存器()；然后把当前地栈指针()拷贝到，做为新地基地址；最后为本地变量留出一定空间，把减去适当地数值.在函数体中定义地变量通常是在栈上，用, , 等分配内存地函数分配得到地就是在堆上.在所有函数体外定义地是全局量，加了修饰符后不管在哪里都存放在全局区（静态区），在所有函数体外定义地变量表示在该文件中有效，不能到别地文件用；在函数体内定义地表示只在该函数体内有效.另外，函数中地""这样地字符串存放在常量区.对比：个人收集整理勿做商业用途性能栈：栈存在于中.栈是动态地，它地存储速度是第二快地.堆：堆位于中，是一个通用地内存池.所有地对象都存储在堆中.申请方式【栈】: 由系统自动分配. 例如，声明在函数中一个局部变量; 系统自动在栈中为开辟空间 .【堆】: 需要程序员自己申请，并指明大小，在中函数如( *)(); 在中用运算符如( *)(); 但是注意：、本身是在栈中地.申请后系统地响应栈【】：只要栈地剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出. 个人收集整理勿做商业用途堆【】：首先应该知道操作系统有一个记录空闲内存地址地链表，当系统收到程序地申请时，会遍历该链表，寻找第一个空间大于所申请空间地堆结点，然后将该结点从空闲结点链表中删除，并将该结点地空间分配给程序；另外，对于大多数系统，会在这块内存空间中地首地址处记录本次分配地大小，这样，代码中地语句才能正确地释放本内存空间.另外，由于找到地堆结点地大小不一定正好等于申请地大小，系统会自动地将多余地那部分重新放入空闲链表中.申请大小地限制栈【】：在下，栈是向低地址扩展地数据结构，是一块连续地内存地区域.这句话地意思是栈顶地地址和栈地最大容量是系统预先规定好地，在下，栈地大小是（也有地说是，总之是一个编译时就确定地常数），如果申请地空间超过栈地剩余空间时，将提示.因此，能从栈获得地空间较小. 个人收集整理勿做商业用途堆【】：堆是向高地址扩展地数据结构，是不连续地内存区域.这是由于系统是用链表来存储地空闲内存地址地，自然是不连续地，而链表地遍历方向是由低地址向高地址.堆地大小受限于计算机系统中有效地虚拟内存.由此可见，堆获得地空间比较灵活，也比较大.申请效率地比较栈【】：由系统自动分配，速度较快.但程序员是无法控制地. 个人收集整理勿做商业用途堆【】：是由分配地内存，一般速度比较慢，而且容易产生内存碎片，不过用起来最方便.另外，在下，最好地方式是用分配内存，他不是在堆，也不是在栈是直接在进程地地址空间中保留一快内存，虽然用起来最不方便.但是速度快，也最灵活.堆和栈中地存储内容栈【】：在函数调用时，第一个进栈地是主函数中后地下一条指令（函数调用语句地下一条可执行语句）地地址，然后是函数地各个参数，在大多数地编译器中，参数是由右往左入栈地，然后是函数中地局部变量.注意静态变量是不入栈地. 个人收集整理勿做商业用途当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存地地址，也就是主函数中地下一条指令，程序由该点继续运行.堆【】：一般是在堆地头部用一个字节存放堆地大小.堆中地具体内容有程序员安排.存取效率地比较[] "";* "";是在运行时刻赋值地；而是在编译时就确定地；但是，在以后地存取中，在栈上地数组比指针所指向地字符串(例如堆)快.比如：(){;[] "";* "";[];[];;}对应地汇编代码: [];[][]: [];[][][]第一种在读取时直接就把字符串中地元素读到寄存器中，而第二种则要先把指针值读到中，在根据读取字符，显然慢了.小结：堆和栈地区别可以用如下地比喻来看出：使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他地好处是快捷，但是自由度小.使用堆就象是自己动手做喜欢吃地菜肴，比较麻烦，但是比较符合自己地口味，而且自由度大.个人收集整理勿做商业用途。
静态存储区和堆栈
一.基础知识
例子程序
int a = 0; //全局初始化区 char *p1;// 全局未初始化区 main() { int b; //栈 char s[] = "abc"; //栈 char *p1,*p2; //栈 char *p3 = "123456"; //123456\0在常量区，p3在栈上。 static int c =0； //全局（静态）初始化区 p1 = (char *)malloc(10); p2 = (char *)malloc(20); strcpy(p1, "123456"); } 分配得来得10和20字节的区域就在堆区。 strcpy(p1, "123456"); 123456\0放在常量区，编译
三.堆和栈的比较
3、申请大小的限制
栈：在Windows下,栈是向低地址扩展的数据结构， 是一块连续的内存的区域。这句话的意思是栈顶的地 址和栈的最大容量是系统预先规定好的，在 WINDOWS下，栈的大小是2M（也有的说是1M，总 之是一个编译时就确定的常数），如果申请的空间超 过栈的剩余空间时，将提示overflow。因此，能从栈 获得的空间较小。 堆：堆是向高地址扩展的数据结构，是不连续的内存 区域。这是由于系统是用链表来存储的空闲内存地址 的，自然是不连续的，而链表的遍历方向是由低地址 向高地址。堆的大小受限于计算机系统中有效的虚拟 内存。由此可见，堆获得的空间比较灵活，也比较大。
一.基础知识
4、堆区（heap）
堆 竞争造成的速度减慢。当两个或多个线程同时访问数 据，而且一个线程继续进行之前必须等待另一个线程完 成时就发生竞争。竞争总是导致麻烦；这也是目前多处 理 器系统遇到的最大问题 堆 破坏造成的速度减慢。造成堆破坏的原因是应用程序 对堆块的不正确使用。通常情形包括释放已释放的堆块 或使用已释放的堆块，以及块的越界重写等明显问题。 频繁的分配和重分配造成的速度减慢。这是使用脚本语 言时非常普遍的现象。如字符串被反复分配，随重分配 增长和释放。不要这样做，如果可能，尽量分配大字符 串和使用缓冲区。另一种方法就是尽量少用连接操作
堆、栈、BSS、Data、code区、静态存储区、文字常量区
堆、栈、BSS、Data、code区、静态存储区、⽂字常量区在计算机领域，堆栈是⼀个不容忽视的概念，但是很多⼈甚⾄是计算机专业的⼈也没有明确堆栈其实是两种数据结构。
要点：堆：顺序随意栈：先进后出堆和栈的区别⼀、预备知识—程序的内存分配⼀个由c/C++编译的程序占⽤的内存分为以下⼏个部分1、栈区（stack）— 由编译器⾃动分配释放，存放函数的参数值，局部变量的值等。
其操作⽅式类似于数据结构中的栈。
2、堆区（heap） — ⼀般由程序员分配释放，若程序员不释放(就会造成内存泄漏的问题)，程序结束时可能由OS回收。
注意它与数据结构中的堆是两回事，分配⽅式倒是类似于链表，呵呵。
3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在⼀块的，初始化的全局变量和静态变量在⼀块区域(data)，未初始化的全局变量和未初始化的静态变量在相邻的另⼀块区域（BSS，Block Started by Symbol）。
- 程序结束后有系统释放(在整个程序的执⾏过程中都是有效的)4、⽂字常量区 —常量字符串就是放在这⾥的。
程序结束后由系统释放 (⽂字常量区内的数据可以修改吗？)5、程序代码区(code)—存放函数体的⼆进制代码。
⼆、例⼦程序这是⼀个前辈写的，⾮常详细//main.cppint a = 0; 全局初始化区char *p1; 全局未初始化区main(){int b; 栈char s[] = "abc"; 栈 //abc是在栈⾥⾯，⽽下⾯的123456/0却在在常量区内，要注意这两种情况的区别char *p2; 栈char *p3 = "123456"; 123456/0在常量区，p3在栈上。
static int c =0；全局（静态）初始化区p1 = (char *)malloc(10);p2 = (char *)malloc(20);分配得来得10和20字节的区域就在堆区。
C语言中内存分布及程序运行中（BSS段、数据段、代码段、堆栈）
C语⾔中内存分布及程序运⾏中（BSS段、数据段、代码段、堆栈）BSS段:（bss segment）通常是指⽤来存放程序中未初始化的全局变量的⼀块内存区域。
BSS是英⽂Block Started by Symbol的简称。
BSS 段属于静态内存分配。
数据段：数据段（data segment）通常是指⽤来存放程序中已初始化的全局变量的⼀块内存区域。
数据段属于静态内存分配。
代码段：代码段（code segment/text segment）通常是指⽤来存放程序执⾏代码的⼀块内存区域。
这部分区域的⼤⼩在程序运⾏前就已经确定，并且内存区域通常属于只读 , 某些架构也允许代码段为可写，即允许修改程序。
在代码段中，也有可能包含⼀些只读的常数变量，例如字符串常量等。
程序段为程序代码在内存中的映射.⼀个程序可以在内存中多有个副本.堆（heap）：堆是⽤于存放进程运⾏中被动态分配的内存段，它的⼤⼩并不固定，可动态扩张或缩减。
当进程调⽤malloc/free等函数分配内存时，新分配的内存就被动态添加到堆上（堆被扩张）/释放的内存从堆中被剔除（堆被缩减）栈(stack) ：栈⼜称堆栈，存放程序的局部变量（但不包括static声明的变量， static 意味着在数据段中存放变量）。
除此以外，在函数被调⽤时，栈⽤来传递参数和返回值。
由于栈的先进先出特点，所以栈特别⽅便⽤来保存/恢复调⽤现场。
储动态内存分配,需要程序员⼿⼯分配,⼿⼯释放下图是APUE中的⼀个典型C内存空间分布图例如：#include <stdio.h>int g1=0, g2=0, g3=0;int max(int i){int m1=0,m2,m3=0,*p_max;static n1_max=0,n2_max,n3_max=0;p_max = (int*)malloc(10);printf("打印max程序地址\n");printf("in max: 0x%08x\n\n",max);printf("打印max传⼊参数地址\n");printf("in max: 0x%08x\n\n",&i);printf("打印max函数中静态变量地址\n");printf("0x%08x\n",&n1_max); //打印各本地变量的内存地址printf("0x%08x\n",&n2_max);printf("0x%08x\n\n",&n3_max);printf("打印max函数中局部变量地址\n");printf("0x%08x\n",&m1); //打印各本地变量的内存地址printf("0x%08x\n",&m2);printf("0x%08x\n\n",&m3);printf("打印max函数中malloc分配地址\n");printf("0x%08x\n\n",p_max); //打印各本地变量的内存地址if(i) return 1;else return 0;}int main(int argc, char **argv){static int s1=0, s2, s3=0;int v1=0, v2, v3=0;int *p;p = (int*)malloc(10);printf("打印各全局变量(已初始化)的内存地址\n");printf("0x%08x\n",&g1); //打印各全局变量的内存地址printf("0x%08x\n",&g2);printf("0x%08x\n\n",&g3);printf("======================\n");printf("打印程序初始程序main地址\n");printf("main: 0x%08x\n\n", main);printf("打印主参地址\n");printf("argv: 0x%08x\n\n",argv);printf("打印各静态变量的内存地址\n");printf("0x%08x\n",&s1); //打印各静态变量的内存地址printf("0x%08x\n",&s2);printf("0x%08x\n\n",&s3);printf("打印各局部变量的内存地址\n");printf("0x%08x\n",&v1); //打印各本地变量的内存地址printf("0x%08x\n",&v2);printf("0x%08x\n\n",&v3);printf("打印malloc分配的堆地址\n");printf("malloc: 0x%08x\n\n",p);printf("======================\n");max(v1);printf("======================\n");printf("打印⼦函数起始地址\n");printf("max: 0x%08x\n\n",max);return 0;}打印结果：可以⼤致查看整个程序在内存中的分配情况:可以看出,传⼊的参数,局部变量,都是在栈顶分布,随着⼦函数的增多⽽向下增长.函数的调⽤地址(函数运⾏代码),全局变量,静态变量都是在分配内存的低部存在,⽽malloc分配的堆则存在于这些内存之上,并向上⽣长.~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~在操作系统中，⼀个进程就是处于执⾏期的程序（当然包括系统资源），实际上正在执⾏的程序代码的活标本。
堆栈的名词解释
堆栈的名词解释堆栈是计算机领域中一个重要的概念，它是一种数据结构，用于存储和管理数据。
堆栈的特点主要体现在数据存储和访问的方式上，它采用“后进先出”（Last-In-First-Out，简称LIFO）的策略，即最后进入堆栈的数据首先被访问。
1. 堆栈的基本原理堆栈由两个主要操作组成：压入（Push）和弹出（Pop）。
当数据需要被添加到堆栈中时，使用压入操作将数据放置在堆栈的顶部；而当数据需要被访问或移除时，使用弹出操作将顶部的数据取出。
这种方式确保了最后添加的数据能够最先被处理，类似于将数据放置在空心的立方体中，只能从顶部进行操作。
2. 堆栈的实际应用堆栈在计算机领域有着广泛的应用，尤其在编程和算法设计中扮演着重要的角色。
堆栈可以用来解决很多实际问题，比如表达式求值、函数调用、内存管理等。
2.1 表达式求值在数学表达式的求值过程中，堆栈可以帮助解决算术优先级问题。
将表达式的各个操作数和运算符通过压入操作按正确的顺序入栈，然后使用弹出操作依次取出并计算，最终得到求值结果。
2.2 函数调用在程序开发中，函数调用是非常常见的操作。
当一个函数被调用时，所有的局部变量和函数参数将被压入堆栈中，函数执行完毕后再依次通过弹出操作移除。
这种方式保证了函数之间的数据独立性和内存分配的有序性。
2.3 内存管理堆栈也可以用于内存管理。
当程序需要为局部变量分配内存空间时，会通过压栈操作将其保存在堆栈中。
当变量不再需要时，可以通过弹出操作从堆栈中释放内存，从而实现对内存的高效管理。
3. 堆栈的实现方式在计算机中，堆栈可以通过不同的数据结构来实现，比较常见的有数组和链表。
3.1 数组实现使用数组实现堆栈是一种简单且高效的方式。
数组具有随机访问的特性，只需通过指针指向栈顶元素即可。
压入操作只需将元素放置在栈顶指针的下一个位置，而弹出操作则是将栈顶元素移除。
3.2 链表实现链表实现堆栈也是一种常见的方式。
链表中的每个节点都包含一个数据元素和一个指向下一个节点的指针。
C语言内存管理堆栈和静态存储区
C语言内存管理堆栈和静态存储区C语言内存管理：堆、栈和静态存储区C语言作为一种高效而强大的编程语言，其内存管理是程序员必须掌握的重要内容之一。
本文将重点介绍C语言中的内存管理中的堆、栈以及静态存储区。
一、堆堆是C语言中用于动态内存分配的一块内存区域。
在程序运行时，可以通过函数malloc()和calloc()来申请堆空间，通过函数free()来释放堆空间。
堆的特点：1. 大小可变：堆中的内存空间大小可以在程序运行时进行动态调整。
2. 生命周期自由控制：通过malloc()或calloc()分配的堆空间，在不再使用后，需要程序员手动调用free()函数进行释放。
堆的使用场景：1. 动态数组：当程序无法预先知道数组大小时，可以使用堆来动态申请空间。
2. 链表：链表结构通常需要通过堆来进行动态内存分配。
二、栈栈是C语言中用于函数调用和局部变量存储的一块内存区域。
在函数调用过程中，栈会记录函数的调用顺序、调用参数以及局部变量等。
栈的特点：1. 后进先出：栈是一种后进先出（LIFO）的数据结构，函数调用时会依次将函数入栈，并在函数返回时依次出栈。
2. 自动管理：栈内存的分配和释放是由编译器自动完成的，程序员无需手动管理。
栈的使用场景：1. 函数调用：栈用于管理函数的调用顺序以及函数内部的局部变量。
2. 递归：递归函数的调用过程涉及到栈的递归压栈和递归出栈。
三、静态存储区静态存储区是C语言中使用static关键字声明的变量所存储的内存区域。
在程序运行期间，静态变量在内存中的位置始终不变，且仅在程序结束时才会释放。
静态存储区的特点：1. 生命周期长：静态变量在程序运行期间都存在，不依赖于函数的调用和返回。
2. 全局可访问：静态变量可以在整个程序中被访问，不受函数作用域的限制。
静态存储区的使用场景：1. 全局变量：使用static关键字声明的全局变量存储在静态存储区中，可以在整个程序中被访问。
2. 共享数据：多个函数之间需要共享的数据可以使用静态变量来实现。
代码段、数据段、堆栈段、数据段辨析
代码段、数据段、堆栈段、数据段辨析1、⾼位地址：栈（存放着局部变量和函数参数等数据），向下⽣长（可读可写可执⾏）2、堆（给动态分配内存是使⽤），向上⽣长（可读可写可执⾏）3、数据段(保存全局数据和静态数据) (可读可写不可执⾏)4、地位地址：代码段（保存代码）（可读可执⾏不可写）代码段就是存储程序⽂本的，所以有时候也叫做⽂本段，指令指针中的指令就是从这⾥取得。
这个段⼀般是可以被共享的，⽐如你在Linux 开了2个Vi来编辑⽂本，那么⼀般来说这两个Vi是共享⼀个代码段的，但是数据段不同（这点有点类似C++中类的不同对象共享相同成员函数）。
数据段是存储数据⽤的，还可以分成初始化为⾮零的数据区，BSS，和堆(Heap)三个区域。
初始化⾮零数据区域⼀般存放静态⾮零数据和全局的⾮零数据。
BSS是Block Started by Symbol的缩写，原本是汇编语⾔中的术语。
该区域主要存放未初始化的全局数据和静态数据。
还有就是堆了，这个区域是给动态分配内存是使⽤的，也就是⽤malloc等函数分配的内存就是在这个区域⾥的。
它的地址是向上增长的。
最后⼀个堆栈段（注意，堆栈是Stack,堆是Heap，不是同⼀个东西），堆栈可太重要了，这⾥存放着局部变量和函数参数等数据。
例如递归算法就是靠栈实现的。
栈的地址是向下增长的。
具体如下：========⾼地址 =======程序栈堆栈段向下增长“空洞” =======向上增长堆------ 数据段BSS------⾮零数据=========低地址 ================ =======代码代码段========= =======需要注意的是，代码段和数据段之间有明确的分隔，但是数据段和堆栈段之间没有，⽽且栈是向下增长，堆是向上增长的，因此理论上来说堆和栈会“增长到⼀起”，但是操作系统会防⽌这样的错误发⽣，所以不⽤过分担⼼。
局部变量、全局变量、堆、堆栈、静态和全局变量
局部变量、全局变量、堆、堆栈、静态和全局变量一般全局变量存放在数据区，局部变量存放在栈区，动态变量存放在堆区，函数代码放在代码区。
---------------------------------------------------------------栈区是普通的栈数据结构,遵循LIFO后进先出的规则,局部变量安排在那里是ASM时就规定的,这样可以在一个函数结束后平衡堆栈,操作简单,效率高堆(动态区)在这里应当叫堆栈(不要和数据结构中的堆搞混)是程序在编译时产生的一块用于产生动态内存分配使用的块,操作比较栈要麻烦许多,在分配时要判断最优的地址(防止产生无用的内存碎片(由于屡次的NEW和DELETE产生的夹在两块使用中内存中的空余小内存(不容易被分配))),分配和回收时的效率比栈低多了---------------------------------------------------------------栈是系统提供的功能，特点是快速高效，缺点是有限制，数据不灵活；而堆是函数库提供的功能，特点是灵活方便，数据适应面广泛，但是效率>有一定降低。
栈是系统数据结构，对于进程/线程是唯一的；堆是函数库内部数据结构，不一定唯一。
不同堆分配的内存无法互相操作。
栈空间分静态分配和动态分配两种。
静态分配是编译器完成的，比如自动变量(auto)的分配。
动态分配由malloca函数完成。
栈的动态分配无需释放(是自动的)，也就没有释放函数。
为可移植的程序起见，栈的动态分配操作是不被鼓励的！堆空间的分配总是动态的，虽然程序结束时所有的数据空间都会被释放回系统，但是精确的申请内存/ 释放内存匹>配是良好程序的基本要素。
堆是程序员管理的,栈是系统管理的.另外关于静态和全局的一些问题：静态变量的特点：1、一次存储：静态局部变量只被初始化一次，下一次初始化根据上一次的结果值，有点类似于c++中类的静态成员变量，即无论该类型生成多少个实例对象，所有的对象共用一个静态变量，到这里就是无论这个函数调用多少次，该静态变量只初始化一次，并没有因为超出其生存期而被销毁，只是外部不可见而已，用个例子说明之：void fun1( int v ){static int value = v;static int value = v;}int main( int arc, char*args[ ]){fun1( 50 );fun1( 100 );}执行的结果是：value : 50 value : 50说明在第二次调用fun1( )时的初始化value的采用的是上一次value的值，value在静态区的存储空间并没有因为fun1( )的结束而被释放，即体现了一次存储；2、作用域限定：静态修饰的作用域限定功能同时体现在函数与变量上；a)对于函数而言，任何用static修饰的函数，其作用域仅为当前源文件，而对外部来说这个函数是不可见的，即只有和其在同一源文件中的函数才能调用这个静态函数；反过来说，如果一个函数仅仅被同一源文件中的其他函数调用，那么这个函数应该声明为静态的，这样做的好处在于：可以一定程度上的解决不同源文件之间函数的命名冲突问题；b)对于变量而言，static修饰的全局变量，只在当前源文件中有效，对外部不可见，外部文件不能够引用；顾名思义，全局变量是指能够在全局引用的变量，相对于局部变量的概念，也叫外部变量；同静态变量一样，全局变量位于静态数据区，全局变量一处定义，多处引用，用关键字“extern”引用“外部”的变量。
计算机中堆栈的概念
计算机中堆栈的概念这两天学习win32的API，了解到了计算机中堆栈的概念，相信很多程序员有时候也弄不明⽩计算机中的堆栈的。
再次为堆栈做⼀下详细解析。
在英⽂中，我们管栈称为stack，管堆称为heap。
在计算机中，堆栈是两种不同的数据结构，但堆栈均为⼀种按序排列的数据结构。
只能在⼀端对数据项进⾏插⼊和删除。
其中的关键是，堆，的排列顺序是随意的，⽽栈，排列顺序是先进后出（First In Last Out）。
堆：为编译器⾃动的分配与释放，⽤来存放函数的参数值与局部变量。
其操作⽅式类似于数据结构中的栈。
栈使⽤的是⼀级缓存，通常都是在调⽤时候存储于存储空间中，在⽤完后由编译器⾃动的释放。
堆：为编程⼈员分配与释放，如果在程序结束的时候没有释放，⼀般会被OS所回收，分配⽅式类似于链表。
堆⼀般存储于⼆级缓存。
数据结构，堆可以被看成⼀棵树。
栈则是⼀种先进后出的数据结构。
在具体介绍之前，我们应该介绍⼀下在C或者C++语⾔中变量的存储区域。
1，栈区（stack）：这块区域由编译器分配与释放内存空间，⼀般存储函数的参数值与局部变量值。
类似于数据结构中的栈。
2，堆区（heap）：这块区域由程序员⾃⼰分配与释放，其余数据结构中的堆是两码事，分配⽅式类似于链表。
3，全局区（静态变量区）：这块存储区域⽤于存储全局变量（global）和静态变量（static），初始化的全局变量和静态变量存储于⼀块区域，未初始化的全局变量和静态变量存储于另⼀块区域。
程序结束后系统⾃动释放。
4，⽂字常量区（静态缓冲区）：这块区域⽤于存储常量静态字符串，在前⾯⽂章我有提到过并且演⽰过，⽤于存放const char*类型的变量。
在程序运⾏中，是不可能对其进⾏修改的，如果修改的话，程序将会报错并且crush，程序结束后由系统⾃动释放。
5，程序代码区：该区域⽤于存放函数体的⼆进制代码。
下⾯，我⽤⼀段程序来解释在什么地⽅存放各种变量。
上⾯的例⼦完全诠释了各种变量存储的地⽅在程序中。
STM32堆栈分析
三、STM32堆栈区预备知识：一个由C/C++编译的程序占用的内存分为以下几个部分：●栈区（stack）：编译器自动分配释放，存放函数的参数值，局部变量的值等。
操作方式类似于数据结构中的栈。
●堆区（heap）：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。
注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。
●全局区（静态区）（static）：全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。
程序结束后由系统释放。
●文字常量区—常量字符串就是放在这里的。
程序结束后由系统释放●程序代码区—存放函数体的二进制代码编译后，各个区存储内容举例说明如下：//main.cppint 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"优化成一个地方。
}STM32的分区STM32的分区从0x2000 0000（0x2000 0000是SRAM的起始地址，由此可知，堆栈等都是在RAM中的）开始。
静态区，堆，栈。
所有的全局变量，包括静态变量之类的，全部存储在静态存储区。
紧跟静态存储区之后的，是堆区（如没用到malloc，则没有该区），之后是栈区，栈在程序中存储局部变量。
先看启动文件startup_stm32f10x_md.s的定义：; Amount of memory (in bytes) allocated for Stack; Tailor this value to your application needs; <h> Stack Configuration; <o> Stack Size (in Bytes) <0x0-0xFFFFFFFF:8>; </h>Stack_Size EQU 0x00000400AREA STACK, NOINIT, READWRITE, ALIGN=3Stack_Mem SPACE Stack_Size__initial_sp; <h> Heap Configuration; <o> Heap Size (in Bytes) <0x0-0xFFFFFFFF:8>; </h>Heap_Size EQU 0x00000200AREA HEAP, NOINIT, READWRITE, ALIGN=3__heap_baseHeap_Mem SPACE Heap_Size__heap_limit这里定义了堆栈各自大小，堆：512bytes 栈1k；所以栈区大小有限制，我们在局部变量中不要定义大数组否则容易溢出。
数据区_代码区_堆栈区_操作系统堆栈
定义结构体指针时，有没有同时分配存储空间啊？看到结构体的数组定义好以后就直接可以用了。
但是结构体指针在链表中还要malloc（）申请空间。
这是为什么啊？定义结构体指针时并没有分配存储空间，所以要用malloc（）申请空间。
它都不知道要分配多大空间啊下面仅仅是定义一个类型，不会产生变量，所以不存在分配空间的问题struct data{int i;int j;};void main(void){struct data dat1; //定义一个struct data类型的变量，和int i同理。
printf("%d\n", sizeof(struct data)); //8个字节printf("%d\n", sizeof(dat1)); //8个字节struct data* pdat1;//定义一个struct data类型的指针，和int *pi 同理。
printf("%d\n", sizeof(pdat1)); //4个字节,就是一个指针的空间，pdat1并没有结构体变量的信息。
pdat1 = (struct data*)malloc(sizeof(struct data)); //申请一个空间，把该空间地址给pdat1.printf("%d\n", sizeof(*pdat1)); //8个字节struct data dats1[2];printf("%d\n", sizeof(dats1)); //16个字节，两个data变量，不是data指针。
dats1[0].i = 20; //可以直接使用数组里面的结构体变量dats1[0].j = 30;struct data* dats2[2]; //指针数组，包含两个指针，而不是结构体变量printf("%d\n", sizeof(dats2)); //8个字节，两个指针的大小dats2[0]->i = 20; //错误！还没有给dats2[0] 指针分配空间dats2[0]->i = 20; //错误！还没有给dats2[0] 指针分配空间dats2[0] = (struct data*)malloc(sizeof(struct data)); //分配空间dats2[0]->i = 20; //okdats2[0]->i = 20; //ok}声明任何对象并定义变量，除了静态成员在一个特别的区，其他的在栈上开辟空间，不用了自动清理，用malloc, realloc, calloc, new new[]开辟空间是动态分配空间，在堆上进行。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
堆、栈及静态数据区详解五大内存分区在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。
栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。
里面的变量通常是局部变量、函数参数等。
堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。
如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free 来结束自己的生命的。
全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多）明确区分堆与栈在bbs上，堆与栈的区分问题，似乎是一个永恒的话题，由此可见，初学者对此往往是混淆不清的，所以我决定拿他第一个开刀。
首先，我们举一个例子：void f() { int* p=new int[5]; }这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们分配了一块堆内存，那么指针p呢？他分配的是一块栈内存，所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p。
在程序会先确定在堆中分配内存的大小，然后调用operator new分配内存，然后返回这块内存的首地址，放入栈中，他在VC6下的汇编代码如下：00401028 push 14h0040102A call operator new (00401060)0040102F add esp,400401032 mov dword ptr [ebp-8],eax00401035 mov eax,dword ptr [ebp-8]00401038 mov dword ptr [ebp-4],eax这里，我们为了简单并没有释放内存，那么该怎么去释放呢？是delete p么？澳，错了，应该是delete []p，这是为了告诉编译器：我删除的是一个数组，VC6就会根据相应的Cookie 信息去进行释放内存的工作。
好了，我们回到我们的主题：堆和栈究竟有什么区别？主要的区别由以下几点：1、管理方式不同；2、空间大小不同；3、能否产生碎片不同；4、生长方向不同；5、分配方式不同；6、分配效率不同；管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制，容易产生memory leak。
空间大小：一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的。
但是对于栈来讲，一般都是有一定的空间大小的，例如，在VC6下面，默认的栈空间大小是1M（好像是，记不清楚了）。
当然，我们可以修改：打开工程，依次操作菜单如下：Project->Setting->Link，在Category 中选中Output，然后在Reserve中设定堆栈的最大值和commit。
注意：reserve最小值为4Byte；commit是保留在虚拟内存的页文件里面，它设置的较大会使栈开辟较大的值，可能增加内存的开销和启动时间。
碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。
对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详细的可以参考数据结构，这里我们就不再一一讨论了。
生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的，是向着内存地址减小的方向增长。
分配方式：堆都是动态分配的，没有静态分配的堆。
栈有2种分配方式：静态分配和动态分配。
静态分配是编译器完成的，比如局部变量的分配。
动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。
分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。
堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。
显然，堆的效率比栈要低得多。
从这里我们可以看到，堆和栈相比，由于大量new/delete的使用，容易造成大量的内存碎片；由于没有专门的系统支持，效率很低；由于可能引发用户态和核心态的切换，内存的申请，代价变得更加昂贵。
所以栈在程序中是应用最广泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地址，EBP和局部变量都采用栈的方式存放。
所以，我们推荐大家尽量用栈，而不是用堆。
虽然栈有如此众多的好处，但是由于和堆相比不是那么灵活，有时候分配大量的内存空间，还是用堆好一些。
无论是堆还是栈，都要防止越界现象的发生（除非你是故意使其越界），因为越界的结果要么是程序崩溃，要么是摧毁程序的堆、栈结构，产生以想不到的结果,就算是在你的程序运行过程中，没有发生上面的问题，你还是要小心，说不定什么时候就崩掉，那时候debug可是相当困难的：）对了，还有一件事，如果有人把堆栈合起来说，那它的意思是栈，可不是堆，呵呵，清楚了？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 用以生成唯一的标志。