堆和栈是什么意思
堆和栈的区别是什么？
堆和栈的区别是什么？⾸先，讨论的堆和栈指的是内存中的“堆区”和“栈区”，OC语⾔是C语⾔的超集，所以先了解C语⾔的内存模型的内存管理会有很⼤的帮助。
C 语⾔的内存模型分为5个区：栈区、堆区、静态区、常量区、代码区。
每个区存储的内容如下：1、栈区：存放函数的参数值、局部变量等，由编译器⾃动分配和释放，通常在函数执⾏完后就释放了，其操作⽅式类似于数据结构中的栈。
栈内存分配运算内置于CPU的指令集，效率很⾼，但是分配的内存量有限，⽐如iOS中栈区的⼤⼩是2M。
2、堆区：就是通过new、malloc、realloc分配的内存块，编译器不会负责它们的释放⼯作，需要⽤程序去释放。
分配⽅式类似于数据结构中的链表。
在iOS开发中所说的“内存泄漏”说的就是堆区的内存。
3、静态区：全局变量和静态变量（在iOS中就是⽤static修饰的局部变量或全局变量）的存储是放在⼀块的，初始化的全局变量和静态变量在⼀块区域，未初始化的全局变量和未初始化的静态变量在相邻的另⼀块区域。
程序结束后，由系统释放。
4、常量区：常量存储在这⾥，不允许修改。
5、代码区：存放函数体的⼆进制代码。
堆和栈的区别：1、堆空间的内存是动态分配的，⼀般存放对象，并且需要⼿动释放内存。
当然，iOS引⼊了ARC（⾃动引⽤计数管理技术）之后，程序员就不需要⽤代码管理对象的内存了，之前MRC（⼿动管理内存）的时候，程序员需要⼿动release对象。
另外，ARC只是⼀种中间层的技术，虽然在ARC模式下，程序员不需要像之前那么⿇烦管理内存，但是需要遵循ARC技术的规范操作，⽐如使⽤属性限定符weak、strong、assigen等。
因此，如果程序员没有按ARC的规则并合理的使⽤这些属性限定符的话，同样是会造成内存泄漏的。
2、栈空间的内存是由系统⾃动分配，⼀般存放局部变量，⽐如对象的地址等值，不需要程序员对这块内存进⾏管理，⽐如，函数中的局部变量的作⽤范围（⽣命周期）就是在调完这个函数之后就结束了。
堆、栈的概念与理解
1、从数据结构层次理解，栈是一种先进后出的线性表，只要符合先进后出的原则的线性表都是栈。至于采用的存储方式（实现方式）是顺序存储（顺序栈）还是链式存储（链式栈）是没有关系的。堆则是二叉树的一种，有最大堆最小堆，排序算法中有常用的堆排序。
2、从系统层次理解，栈是系统为运行的程序分配的先进后出的存储区域。在学习bootloader时知道，在上电后初始化阶段要为各个工作模式下分配堆 栈，这里的堆栈实际上就是指stack，堆栈的说法只是因为历史的原因。在执行函数时，函数内部局部变量的存储单元可以在栈上创建（针对CISC架构而 言，RISC架构下，局部变量的存储单元是在寄存器上创建），函数执行结束时这些存储单元自动被释放。堆是系统管理的可以被程序利用的全局存储空间，动态 内存分配就是从堆上分配。
什么是堆什么是栈
一 英文名称
堆和栈是C/C++编程中经常遇到的两个基本概念。先看一下它们的英文表示：
堆――heap
栈――stack
二 从数据结构和系统两个层次理解
在具体的C/C++编程框架中，这两个概念并不是并行的。深入到汇编级进行研究就会发现，栈是机器系统提供的数据结构，而堆是由C/C++函数库提供的。这两个概念可以从数据结构和系统两个层次去理解：
具体地说，现在计算机（串行执行机制），都直接在代码层次支持栈这种数据结构。这体现在，有专门的寄存器指向栈所在的地址，有专门的机器指令完成数据入栈 出栈的操作。比如ARM指令中的stmfd和ldmfd。因为栈内存分配运算内置于处理器的指令集中，所以效率很高，但是支持的数据有限，一般是整数、指 针、浮点数等系统直接支持的数据类型，并不直接支持其他的数据结构。在CISC中，对子程序的调用就是利用栈来完成的。C/C++中的自动变量也是直接利 用栈的例子，这就是为什么当函数返回时，该函数的自动变量失效的原因（因为栈恢复了调用前的状态）。在RISC下，这些都是通过寄存器来完成的。这些留待 第二部分总结中详细阐述。
堆栈及静态数据区详解
堆、栈及静态数据区详解五大内存分区在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 信息去进行释放内存的工作。
C语言中堆的名词解释
C语言中堆的名词解释堆（Heap）是C语言中的一种动态内存分配方式，它相对于栈（Stack）来说，拥有更大的内存空间并且能够存储具有更长生命周期的数据。
在本文中，我们将解释堆的概念、特性以及在C语言中的应用。
一、堆的概念和特性堆是C语言中一块动态分配的内存区域，用于存储程序运行期间需要长时间保留的数据。
与栈不同，堆的内存分配和释放并不自动管理，而是需要通过程序员手动控制。
堆的主要特性可以概括为以下几点：1. 大小可变：堆的大小取决于操作系统的内存限制，可以动态地增加或缩小。
2. 不连续性：堆内存中的数据块可以被随意分配和释放，它们的位置通常是不连续的。
3. 长生命周期：堆中分配的内存空间在程序运行期间一直存在，直到显式地释放。
4. 存储动态数据：堆用于存储运行时动态创建的数据，例如对象、数组、链表等。
二、堆的内存分配在C语言中，使用malloc函数来动态分配堆内存。
malloc的完整形式是memory allocation（内存分配），其原型如下：```cvoid* malloc(size_t size);malloc函数接受一个size_t类型的参数，表示需要分配的内存空间大小，返回一个void指针，指向分配的内存起始地址。
若分配失败，则返回一个空指针NULL。
以下是一个使用malloc分配堆内存的示例：```cint* ptr = (int*) malloc(sizeof(int));```在上述示例中，我们使用malloc函数分配了一个int类型的内存空间并将其地址赋值给了ptr指针。
这样，我们就可以通过访问ptr来操作这个堆内存空间。
需要注意的是，使用malloc函数分配的堆内存必须在使用完毕后通过调用free 函数来显式地释放，以避免内存泄漏。
free函数的原型如下：```cvoid free(void* ptr);```free函数接受一个void指针作为参数，指向需要释放的堆内存的起始地址。
.net中堆和栈的区别(图文解释)
尽管在.NET framework下我们并不需要担心内存管理和垃圾回收(Garbage Collection)，但是我们还是应该了解它们，以优化我们的应用程序。
同时，还需要具备一些基础的内存管理工作机制的知识，这样能够有助于解释我们日常程序编写中的变量的行为。
在本文中我将讲解栈和堆的基本知识，变量类型以及为什么一些变量能够按照它们自己的方式工作。
在.NET framework环境下，当我们的代码执行时，内存中尽管在.NET framework下我们并不需要担心内存管理和垃圾回收(Garbage Collection)，但是我们还是应该了解它们，以优化我们的应用程序。
同时，还需要具备一些基础的内存管理工作机制的知识，这样能够有助于解释我们日常程序编写中的变量的行为。
在本文中我将讲解栈和堆的基本知识，变量类型以及为什么一些变量能够按照它们自己的方式工作。
在.NET framework环境下，当我们的代码执行时，内存中有两个地方用来存储这些代码。
假如你不曾了解，那就让我来给你介绍栈(Stack)和堆(Heap)。
栈和堆都用来帮助我们运行代码的，它们驻留在机器内存中，且包含所有代码执行所需要的信息。
* 栈vs堆：有什么不同？栈负责保存我们的代码执行（或调用）路径,而堆则负责保存对象（或者说数据，接下来将谈到很多关于堆的问题）的路径。
可以将栈想象成一堆从顶向下堆叠的盒子。
当每调用一次方法时，我们将应用程序中所要发生的事情记录在栈顶的一个盒子中,而我们每次只能够使用栈顶的那个盒子。
当我们栈顶的盒子被使用完之后，或者说方法执行完毕之后，我们将抛开这个盒子然后继续使用栈顶上的新盒子。
堆的工作原理比较相似，但大多数时候堆用作保存信息而非保存执行路径，因此堆能够在任意时间被访问。
与栈相比堆没有任何访问限制，堆就像床上的旧衣服，我们并没有花时间去整理，那是因为可以随时找到一件我们需要的衣服，而栈就像储物柜里堆叠的鞋盒，我们只能从最顶层的盒子开始取，直到发现那只合适的。
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的信息。
栈与队列，各有异同。
栈与队列，各有异同。
⾸先是两者的定义：栈也称为堆栈，是⼀种线性表。
栈的特性：最先放⼊栈中的内容最后被拿出来，最后放⼊栈中的内容最先被拿出来，被称为先进后出、后进先出。
队列也是⼀种特殊的线性表。
不同于栈所服从的先进后出的原则，队列的原则是先进先出。
队列在队头做删除操作,在队尾做插⼊操作。
然后是两者的异同点不同点：1.删除数据元素的位置不同，栈的删除操作在表尾进⾏，队列的删除操作在表头进⾏。
2.队列先进先出，栈先进后出。
3.顺序栈能够实现多栈空间共享，⽽顺序队列不能。
4.遍历数据速度不同。
栈只能从头部取数据，也就最先放⼊的需要遍历整个栈最后才能取出来。
队列则不同，它基于地址指针进⾏遍历，⽽且可以从头或尾部开始遍历⽆需开辟临时空间，速度要快的多。
相同点：1.都是。
2.插⼊操作都是限定在表尾进⾏。
3.都可以通过顺序结构和链式结构实现。
4.插⼊与删除的时间复杂度与空间复杂度上两者均相同。
再然后便是两者的表⽰和操作的实现栈表⽰和操作的实现：#include <iostream>#define MAXSIZE 100//基础容量using namespace std;typedef struct{SElemType *top;//栈顶指针SElemType *base;//栈底指针int stacksize;//栈可⽤最⼤容量}SqStack;Status InitStack(SqStack &S)//初始化栈{S.base=new SElemType[MAXSIZE];if(!s.base) exit(OVERFLOW);//内存分配失败S.top=s.base;S.stacksize=MAXSIZE;}Status Push(SqStack &S,SElemType e)//把元素e压⼊栈顶{if(S.top-S.base==S.stacksize) return ERROR;//栈满*S.top++=e;//栈顶指针+1return OK;}Status Pop(SqStack &s,SElemType &e)//取出栈顶元素，并删除栈顶{if(S.top==S.base)//top与base重合时，栈为空return ERROR;e=*--S.top;return OK;}SElemType GetTop(SqStack S){if(S.top!=S.base)return *(S.top-1);}队列表⽰和操作的实现：#ifndef STATICQUEUE_H_INCLUDED#define STATICQUEUE_H_INCLUDEDtemplate<class T>class StaticQueue{public:StaticQueue();StaticQueue(int size);~StaticQueue();void enqueue(T data);T dequeue();bool isEmpty();bool isFull();int count();void display();private:int rear;int front;int size;const static int DEFAULT;T* queue;};这些在课本上都有，下⾯说说遇到的问题：对于作业3，可以说是屡战屡败，屡败屡战了，先是⼀点思路都没有，再到后来⽼师提⽰后有⼀点思路，但还是错误百出，再到后来参照书上的⽅法，还是错误，最后终于发现问题。
队列,栈,堆栈,数组,链表特点与区别
队列，栈，堆栈，数组，链表特点与区别1. 队列可以看成是有2个口的集合一个口叫队头一个叫队尾，只能在对头进行删除操作，在队尾做插入。
根据这样的操作。
队列特点是先进先出2.堆栈可以看成是有1个口的集合，这个口叫栈顶。
插入和删除操作只能在栈顶操作。
根据这样的操作。
堆栈的特点是是后进先出.3.链表是一种存储方式，它可以在非连续的内存空间里面存储一个集合的元素。
4.和它对应的是数组，数组要在连续的空间里存储集合的元素队列、栈是线性数据结构的典型代表，而数组、链表是常用的两种数据存储结构；队列和栈均可以用数组或链表的存储方式实现它的功能数组与链表：数组属于顺序存储中，由于每个元素的存储位置都可以通过简单计算得到，所以访问元素的时间都相同（直接访问数组下标）；链表属于数据的链接存储，由于每个元素的存储位置是保存在它的前驱或后继结点中的，所以只有当访问到其前驱结点或后继结点后才能够按指针访问到自己，访问任一元素的时间与该元素结点在链接存储中的位置有关。
链表和数组是常用的两种数据存储结构，都能用来保存特定类型的数据。
1.占用的内存空间链表存放的内存空间可以是连续的，也可以是不连续的，数组则是连续的一段内存空间。
一般情况下存放相同多的数据数组占用较小的内存，而链表还需要存放其前驱和后继的空间。
2.长度的可变性链表的长度是按实际需要可以伸缩的，而数组的长度是在定义时要给定的，如果存放的数据个数超过了数组的初始大小，则会出现溢出现象。
3.对数据的访问链表方便数据的移动而访问数据比较麻烦；数组访问数据很快捷而移动数据比较麻烦。
链表和数组的差异决定了它们的不同使用场景，如果需要很多对数据的访问，则适合使用数组；如果需要对数据进行很多移位操作，则设和使用链表。
堆和栈有什么区别：1. 栈具有数据结构中栈的特点，后进先出，所有存放在它里面的数据都是生命周期很明确（当然要求它不能存放太久，占有的空间确定而且占用空间小），能够快速反应的！所有在Java中它存放的是8个基本数据类型和引用变量的，用完就马上销毁2.堆可以理解它就是个一个可大可小，任你分配的听话的内存操作单元;因此它的特点就是动态的分配内存，适合存放大的数据量!比如一个对象的所有信息，虽然它的引用指向栈中的某个引用变量；所有Java中堆是存放new 出来的对象的。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
C++堆和栈是什么意思一个由C/C++编译的程序占用的内存分为以下几个部分1、栈区（stack）—由编译器自动分配释放，存放函数的参数值，局部变量的值等。
其操作方式类似于数据结构中的栈。
2、堆区（heap）—一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。
注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。
3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。
- 程序结束后有系统释放4、文字常量区—常量字符串就是放在这里的。
程序结束后由系统释放5、程序代码区—存放函数体的二进制代码。
二、例子程序这是一个前辈写的，非常详细//main.cppint a = 0; 全局初始化区char *p1; 全局未初始化区main(){int b; 栈char s[] = "abc"; 栈char *p2; 栈char *p3 = "123456"; 123456在常量区，p3在栈上。
static int c =0；全局（静态）初始化区p1 = (char *)malloc(10);p2 = (char *)malloc(20);分配得来得10和20字节的区域就在堆区。
strcpy(p1, "123456"); 123456放在常量区，编译器可能会将它与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是在编译时就确定的；但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。
比如：#includevoid 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],cl11: 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小结：堆和栈的区别可以用如下的比喻来看出：使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。
使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。
1、内存分配方面：堆：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。
注意它与数据结构中的堆是两回事，分配方式是类似于链表。
可能用到的关键字如下：new、malloc、delete、free等等。
栈：由编译器(Compiler)自动分配释放，存放函数的参数值，局部变量的值等。
其操作方式类似于数据结构中的栈。
2、申请方式方面：堆：需要程序员自己申请，并指明大小。
在c中malloc函数如p1 = (char*)malloc(10)；在C++中用new运算符，但是注意p1、p2本身是在栈中的。
因为他们还是可以认为是局部变量。
栈：由系统自动分配。
例如，声明在函数中一个局部变量 int b；系统自动在栈中为b开辟空间。
3、系统响应方面：堆：操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样代码中的delete语句才能正确的释放本内存空间。
另外由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动将多余的那部分重新放入空闲链表中。
栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。
4、大小限制方面：堆：是向高地址扩展的数据结构，是不连续的内存区域。
这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。
堆的大小受限于计算机系统中有效的虚拟内存。
由此可见，堆获得的空间比较灵活，也比较大。
栈：在Windows下, 栈是向低地址扩展的数据结构，是一块连续的内存的区域。
这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是固定的（是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。
因此，能从栈获得的空间较小。
5、效率方面：堆：是由new分配的内存，一般速度比较慢，而且容易产生内存碎片，不过用起来最方便，另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。
但速度快，也灵活。
栈：由系统自动分配，速度较快。
但程序员是无法控制的。
6、存放内容方面：堆：一般是在堆的头部用一个字节存放堆的大小。
堆中的具体内容有程序员安排。
栈：在函数调用时第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈，然后是函数中的局部变量。
注意: 静态变量是不入栈的。
当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。
7、存取效率方面：堆：char *s1 = "Hellow Word"；是在编译时就确定的；栈：char s1[] = "Hellow Word"；是在运行时赋值的；用数组比用指针速度要快一些，因为指针在底层汇编中需要用edx寄存器中转一下，而数组在栈上直接读取。
在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。
栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。
里面的变量通常是局部变量、函数参数等。
堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。
如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。
全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多）CONSTC中CONST的使用：const是一个C语言的关键字，它限定一个变量不允许被改变。
使用const在一定程度上可以提高程序的健壮性，另外，在观看别人代码的时候，清晰理解const所起的作用，对理解对方的程序也有一些帮助。
虽然这听起来很简单，但实际上，const的使用也是c语言中一个比较微妙的地方，微妙在何处呢？请看下面几个问题。