堆与栈
栈是由编译器在需要的时分配的，不需要时自动清除的变量存储区。里面的变量通常是局部变量、函数参数等。堆是有malloc()函数（C++语言为new运算符）分配为内存快，内存的释放由程序员手动控制，在C语言为free（）完成（C++中为deleted）。堆和栈的主要区别有以下几点：
（1）管理方式不同
栈编译器自动管理，无需程序员手工控制；而堆空间的申请释放工作由程序员控制，容易产生内存泄漏。
（2）空间的大小不同
栈是向低地址扩展的数据结构，是一块连续的内存区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先设定好，当申请的空间超过栈的剩余空间时，将提示溢出。因此，用户能从栈获得空间较小。
堆是向高地址扩展的数据结构，是不连续的内存区域。因为系统是用链表来存储空闲内存地址的，且链表的遍历方向是由低地址向高地址。由此可见，堆获得空间较灵活，也较大。栈中元素都是一一对应的，不会存在一个内存块从中弹出的情况。
（3）是否产生碎片
对于栈来讲，频繁的malloc/free(new/delete)势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低（虽然程序在退出后操作系统会对内存进行回收管理）。对于栈来讲，则不会存在这个问题。
(4) 增长方向不同
堆的增长方向是向上的，即向着内存地址增加的方向。栈的增长方向是向下的，即向着内存地址减小的方向。
（5）分配方式不同
堆都是程序中由malloc()函数动态申请分配并由free()函数释放的；栈的分配和释放是由编译器完成的，栈的动态分配由alloca（）函数完成，但是栈的动态分配和对不同，它的动态分配是由编译器进行申请和释放的，无需手工实现。
（6）分配效率不同
栈是由机器系统提供的数据结构，计算机会在底层对栈提供支持；分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令进行。堆则是C函数库提供的，它的机制很复杂，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大的空间，如果没有足够大的空间（可能是由于内存碎片太多），就需要操作系统来重新整理内存空间，这样就有机会分到足够大小的内存，然后返回。
显然堆的效率要比栈低得多。
可执行代码运行时内存结构结构：
（1）代码区（text segment）。代码区指令根据程序设计流程依次执行，对于顺序指令，则只会执行一次（每个进程），如果反复，则需要使用跳转指令，如果进行递归，则需要借助栈来实现。
代码区的指令包括操作码和要操作的对象（或对象地址引用）。如果是里技术（及具体的数值），将直接包含在代码中；如果是局部变量，将在栈区分配空间。然后引用该数的地址；如果是BSS去和数据区，在代码中同样是引用该数的地址。
（2）全局初始化数据区/静态数据区（Data Segment）。只初始化一次。
（3）未初始化数据区（BBS）。在运行时改变其值，存入的全局未初始化变量。例如一个不在任何函数内的声明：long sum[1000];
（4）栈区（stack）。由编译器自动分配释放，存放函数的参数值、局部变量的值等。其操作方式类似于数据结构中的栈。每当一个函数被调用，该函数返回地址和一些关于调用的信息，比如某些寄存器的内容改变，被存储对哦栈区。然后这个被调用的函数再为它的自动变量和临时变量在栈区上分配空间，这就是C 实现递归函数的方法。每执行依次函数递归函数调用，一个新的栈框架就会被使用，这样这个新实例栈里的变量就不会和该函数的另一个实例栈里面的变量混淆。
（5）堆区（heap）用于动态内存分配。堆在内存中位于bss区和栈区之间。一般由程序员分配和释放，若程序员不释放，结束程序时有可能由OS回收。
可执行代码存储结构
可执行代码在存储时分为代码区（text），数据区（data）和未初始化数据区（bss）。
计算机算法设计与分析习题和答案解析
《计算机算法设计与分析》习题及答案 一．选择题 1、二分搜索算法是利用（A ）实现的算法。 A、分治策略 B、动态规划法 C、贪心法 D、回溯法 2、下列不是动态规划算法基本步骤的是（A ）。 A、找出最优解的性质 B、构造最优解 C、算出最优解 D、定义最优解 3、最大效益优先是（ A ）的一搜索方式。 A、分支界限法 B、动态规划法 C、贪心法 D、回溯法 4. 回溯法解旅行售货员问题时的解空间树是（ A ）。 A、子集树 B、排列树 C、深度优先生成树 D、广度优先生成树 5．下列算法中通常以自底向上的方式求解最优解的是（ B ）。 A、备忘录法 B、动态规划法 C、贪心法 D、回溯法 6、衡量一个算法好坏的标准是（C ）。 A 运行速度快 B 占用空间少 C 时间复杂度低 D 代码短 7、以下不可以使用分治法求解的是（D ）。 A 棋盘覆盖问题 B 选择问题 C 归并排序 D 0/1背包问题 8. 实现循环赛日程表利用的算法是（ A ）。 A、分治策略 B、动态规划法 C、贪心法 D、回溯法 9．下面不是分支界限法搜索方式的是（ D ）。 A、广度优先 B、最小耗费优先 C、最大效益优先 D、深度优先 10．下列算法中通常以深度优先方式系统搜索问题解的是（ D ）。 A、备忘录法 B、动态规划法 C、贪心法 D、回溯法 11.备忘录方法是那种算法的变形。（B ） A、分治法 B、动态规划法 C、贪心法 D、回溯法 12．哈夫曼编码的贪心算法所需的计算时间为（ B ）。 A、O（n2n） B、O（nlogn） C、O（2n） D、O（n） 13．分支限界法解最大团问题时，活结点表的组织形式是（ B ）。 A、最小堆 B、最大堆 C、栈 D、数组 14．最长公共子序列算法利用的算法是（ B ）。 A、分支界限法 B、动态规划法 C、贪心法 D、回溯法 15．实现棋盘覆盖算法利用的算法是（ A ）。 A、分治法 B、动态规划法 C、贪心法 D、回溯法 16.下面是贪心算法的基本要素的是（ C ）。 A、重叠子问题 B、构造最优解 C、贪心选择性质 D、定义最优解 17.回溯法的效率不依赖于下列哪些因素（ D ） A.满足显约束的值的个数 B. 计算约束函数的时间 C.计算限界函数的时间 D. 确定解空间的时间 18.下面哪种函数是回溯法中为避免无效搜索采取的策略（ B ） A．递归函数 B.剪枝函数C。随机数函数 D.搜索函数 19. （ D ）是贪心算法与动态规划算法的共同点。
堆与栈
栈是由编译器在需要的时分配的，不需要时自动清除的变量存储区。里面的变量通常是局部变量、函数参数等。堆是有malloc()函数（C++语言为new运算符）分配为内存快，内存的释放由程序员手动控制，在C语言为free（）完成（C++中为deleted）。堆和栈的主要区别有以下几点： （1）管理方式不同 栈编译器自动管理，无需程序员手工控制；而堆空间的申请释放工作由程序员控制，容易产生内存泄漏。 （2）空间的大小不同 栈是向低地址扩展的数据结构，是一块连续的内存区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先设定好，当申请的空间超过栈的剩余空间时，将提示溢出。因此，用户能从栈获得空间较小。 堆是向高地址扩展的数据结构，是不连续的内存区域。因为系统是用链表来存储空闲内存地址的，且链表的遍历方向是由低地址向高地址。由此可见，堆获得空间较灵活，也较大。栈中元素都是一一对应的，不会存在一个内存块从中弹出的情况。 （3）是否产生碎片 对于栈来讲，频繁的malloc/free(new/delete)势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低（虽然程序在退出后操作系统会对内存进行回收管理）。对于栈来讲，则不会存在这个问题。 (4) 增长方向不同 堆的增长方向是向上的，即向着内存地址增加的方向。栈的增长方向是向下的，即向着内存地址减小的方向。 （5）分配方式不同 堆都是程序中由malloc()函数动态申请分配并由free()函数释放的；栈的分配和释放是由编译器完成的，栈的动态分配由alloca（）函数完成，但是栈的动态分配和对不同，它的动态分配是由编译器进行申请和释放的，无需手工实现。 （6）分配效率不同 栈是由机器系统提供的数据结构，计算机会在底层对栈提供支持；分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令进行。堆则是C函数库提供的，它的机制很复杂，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大的空间，如果没有足够大的空间（可能是由于内存碎片太多），就需要操作系统来重新整理内存空间，这样就有机会分到足够大小的内存，然后返回。 显然堆的效率要比栈低得多。 可执行代码运行时内存结构结构： （1）代码区（text segment）。代码区指令根据程序设计流程依次执行，对于顺序指令，则只会执行一次（每个进程），如果反复，则需要使用跳转指令，如果进行递归，则需要借助栈来实现。 代码区的指令包括操作码和要操作的对象（或对象地址引用）。如果是里技术（及具体的数值），将直接包含在代码中；如果是局部变量，将在栈区分配空间。然后引用该数的地址；如果是BSS去和数据区，在代码中同样是引用该数的地址。
堆 栈 详 解
堆栈详解及其python实现 wiki定义 堆栈（抽象数据类型） 有关在会计中使用术语LIFO，请参阅LIFO（会计）。对于力量训练中使用术语下推，请参阅下推（练习）。 有关其他用途，请参阅堆栈（消歧）。 使用推送和弹出操作简单表示堆栈运行时。 在计算机科学中，堆栈是一种抽象数据类型，用作元素集合，具有两个主要操作： push，它为集合添加了一个元素，以及 pop，删除最近添加的尚未删除的元素。 元素从堆栈中出现的顺序产生了它的替代名称LIFO（last in，first out）。另外，窥视操作可以在不修改堆栈的情况下访问顶部。[1]这种结构的名称“堆叠”来自于相互堆叠的一组物理项目的类比，这样可以轻松地将物品从堆叠顶部取出，同时获取物品堆叠深度可能需要先取下多个其他物品。[2] 被认为是线性数据结构，或者更抽象地是顺序集合，推送和弹出操作仅发生在结构的一端，称为堆栈的顶部。这使得可以将堆栈实现为单链表和指向顶部元素的指针。可以实现堆栈以具有有界容量。如果堆栈已满并且没有足够的空间来接受要推送的实体，则认为堆栈处于溢出状态。pop 操作从堆栈顶部删除一个项目。
需要堆栈来实现深度优先搜索。 非必要的操作 软件堆栈 堆栈和编程语言 硬件堆栈 堆栈的基本架构 堆叠在主内存中 堆叠在寄存器或专用存储器中 堆栈的应用 表达式评估和语法分析 编译时间内存管理 高效的算法 也可以看看 进一步阅读 另见：Jan?ukasiewicz§工作 Stacks于1946年进入计算机科学文献，当时Alan M. Turing使用术语“埋葬”和“unbury”作为从子程序调用和返回的手段。[3]子程序已于1945年在Konrad Zuse的Z4中实施。 克劳斯·萨梅尔森和弗里德里希·L·包尔的慕尼黑工业大学提出这个构想于1955年并于1957年申请了专利，[4]和1988年3月鲍尔收到的计算机先驱奖为堆原理发明。[5]同样的概念是由澳大利亚人Charles Leonard Hamblin在1954年上半年独立开发的。[6]
C语言堆和栈
在计算机领域，堆栈是一个不容忽视的概念，我们编写的C语言程序基本上都要用到。 但对于很多的初学着来说，堆栈是一个很模糊的概念。堆栈：一种数据结构、一个在程序运 行时用于存放的地方，这可能是很多初学者的认识，因为我曾经就是这么想的和汇编语言中 的堆栈一词混为一谈。我身边的一些编程的朋友以及在网上看帖遇到的朋友中有好多也说不 清堆栈，所以我想有必要给大家分享一下我对堆栈的看法，有说的不对的地方请朋友们不吝 赐教，这对于大家学习会有很大帮助。 首先在数据结构上要知道堆栈，尽管我们这么称呼它，但实际上堆栈是两种数据结构：堆和栈。 堆和栈都是一种数据项按序排列的数据结构。 我们先从大家比较熟悉的栈说起吧，它是一种具有后进先出性质的数据结构，也就是说 后存放的先取，先存放的后取。这就如同我们要取出放在箱子里面底下的东西（放入的比较 早的物体），我们首先要移开压在它上面的物体（放入的比较晚的物体）。而堆就不同了，堆 是一种经过排序的树形数据结构，每个结点都有一个值。通常我们所说的堆的数据结构，是 指二叉堆。堆的特点是根结点的值最小（或最大），且根结点的两个子树也是一个堆。由于 堆的这个特性，常用来实现优先队列，堆的存取是随意，这就如同我们在图书馆的书架上取 书，虽然书的摆放是有顺序的，但是我们想取任意一本时不必像栈一样，先取出前面所有的 书，书架这种机制不同于箱子，我们可以直接取出我们想要的书。 然而我要说的重点并不在这，我要说的堆和栈并不是数据结构的堆和栈，之所以要说数 据结构的堆和栈是为了和后面我要说的堆区和栈区区别开来，请大家一定要注意。 下面就说说C语言程序内存分配中的堆和栈，这里有必要把内存分配也提一下，大家不 要嫌我啰嗦，一般情况下程序存放在Rom或Flash中，运行时需要拷到内存中执行，内存会分 别存储不同的信息，如下图所示：
计算机组成原理堆栈
堆栈是计算机系统中的一个重要概念，也是理解微型计算机组成的一个基础概念。堆栈是一种存储部件，即数据的写入跟读出不需要提供地址，而是根据写入的顺序决定读出的顺序。 堆栈也是一种数据结构。有一个地址指针总指向最后一个压入堆栈的数据所在的数据单元，存放这个地址指针的寄存器就叫做堆栈指示器。数据一个一个地存入，这个过程叫做“压栈”。在压栈的过程中，每有一个数据压入堆栈，就放在和前一个单元相连的后面一个单元中，堆栈指示器中的地址自动加1。读取这些数据时，按照堆栈指示器中的地址读取数据，堆栈指示器中的地址数自动减1。这个过程叫做“出栈pop”。如此就实现了后进先出的原则。 一般的堆栈存储器由RAM、寄存器A,寄存器B构成。算术运算一般在寄存器A和寄存器B 之间进行，其中的数据可能来自于进栈的输入也可能来自栈堆的出栈。运算结果则会放入寄存器B中以待下步操作。 此次的课程设计做出的堆栈处理器，使其能与外部数据总线进行数据交换，且符合堆栈要求（先进后出），并能对存储的数据进行算术运算，且存储的数据的数据位不少于8位，通过数码管显示操作数据及运算结果（只有寄存器A、B 直接与外部总线进行数据交换，RAM只和寄存器B进行数据交换）。 关键词：堆栈，RAM, PUSH, POP , 寄存器A，寄存器B
一. 任务解析 (3) 二. 系统方案论证 (3) 2.1总体方案与比较论证 (3) 2.2 设计思路 (4) 2.3系统原理与结构 (4) 2.3.1 系统框图 (4) 2.3.2 系统结构框图 (5) 2.3.3堆栈电路图 (5) 三. 设计过程 (6) 3.1堆栈存储器的设计 (6) 3.1.1堆栈存储器设计原理及仿真结果 (6) 3.2对数据进行算术运算的设计及仿真 (7) 3.2.1 对存储器中数据进行加法运算 (7) 3.2.2 对存储器中数据进行减法运算 (8) 3.2.3 对存储器中数据进行乘法运算 (8) 3.2.4 对存储器中数据进行除法运算 (9) 四. 总结 (9) 4.1遇到的问题及解决方案 (9) 4.2设计心得 (10) 4.3参考文献 (10)
java中堆和栈的区别
Java中堆与栈的区别 简单的说： Java把内存划分成两种：一种是栈内存，一种是堆内存。 在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。 当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。 堆内存用来存放由new创建的对象和数组。 在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。 1. 栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同，Java 自动管理栈和堆，程序员不能直接地设置栈或堆。 2. 栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。另外，栈数据可以共享，详见第3点。堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。 3. Java中的数据类型有两种。 一种是基本类型(primitive types), 共有8种，即int, short, long, byte, float, double, boolean, char(注意，并没有string的基本类型)。这种类型的定义是通过诸如int a = 3; long b = 255L;的形式来定义的，称为自动变量。值得注意的是，自动变量存的是字面值，不是类的实例，即不是类的引用，这里并没有类的存在。如int a = 3; 这里的a是一个指向int类型的引用，指向3这个字面值。这些字面值的数据，由于大小可知，生存期可知(这些字面值固定定义在某个程序块里面，程序块退出后，字段值就消失了)，出
堆栈及静态数据区详解
堆、栈及静态数据区详解 五大内存分区 在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 14h 0040102A call operator new (00401060) 0040102F add esp,4 00401032 mov dword ptr [ebp-8],eax 00401035 mov eax,dword ptr [ebp-8]
堆与栈,静态变量和全局变量的区别
堆与栈，静态变量和全局变量的区别 堆与栈，静态变量和全局变量的区别 对和栈的主要的区别由以下几点： 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++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。
C++中堆和栈的区别
C++中堆和栈的区别，自由存储区、全局/静态存储区和常量存储区 文章来自一个论坛里的回帖，哪个论坛记不得了！ 在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。 栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。 堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。 自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。 全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的（初始化的全局变量和静态变量在一块区域，未初始化的全局变量与静态变量在相邻的另一块区域，同时未被初始化的对象存储区可以通过void*来访问和操纵，程序结束后由系统自行释放），在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信息去进行释放内存的工作。 好了，我们回到我们的主题：堆和栈究竟有什么区别？ 主要的区别由以下几点： 1、管理方式不同； 2、空间大小不同； 3、能否产生碎片不同； 4、生长方向不同；
堆变量和栈变量
全局，静态，new产生的变量都在堆中 动态分配的变量在堆中分配 局部变量在栈里分配 函数中声明的变量在栈中 用了new标示符在堆中 全局变量和static变量都在全局区 程序为栈变量分配动态内存，在程序结束时为栈变量分配的空间将自动释放;而为堆变量分配的空间则不会自动释放，若在程序中没有没有释放堆变量，它将一直占用系统内存。 堆栈是一种执行“后进先出”算法的数据结构。 设想有一个直径不大、一端开口一端封闭的竹筒。有若干个写有编号的小球，小球的直径比竹筒的直径略小。现在把不同编号的小球放到竹筒里面，可以发现一种规律：先放进去的小球只能后拿出来，反之，后放进去的小球能够先拿出来。所以“先进后出”就是这种结构的特点。 堆栈就是这样一种数据结构。它是在内存中开辟一个存储区域，数据一个一个顺序地存入（也就是“压入——push”）这个区域之中。有一个地址指针总指向最后一个压入堆栈的数据所在的数据单元，存放这个地址指针的寄存器就叫做堆栈指示器。开始放入数据的单元叫做“栈底”。数据一个一个地存入，这个过程叫做“压栈”。在压栈的过程中，每有一个数据压入堆栈，就放在和前一个单元相连的后面一个单元中，堆栈指示器中的地址自动加1。读取这些数据时，按照堆栈指示器中的地址读取数据，堆栈指示器中的地址数自动减 1。这个过程叫做“弹出pop”。如此就实现了后进先出的原则。 堆栈是计算机中最常用的一种数据结构，比如函数的调用在计算机中是用堆栈实现的。 堆栈可以用数组存储，也可以用以后会介绍的链表存储。 下面是一个堆栈的结构体定义，包括一个栈顶指针，一个数据项数组。栈顶指针最开始指向-1,然后存入数据时，栈顶指针加1，取出数据后，栈顶指针减1。 #define MAX_SIZE 100 typedef int DATA_TYPE; struct stack { DATA_TYPE data[MAX_SIZE]; int top; }; 在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。 栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。 堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程
堆栈详解(数据与内存中的存储方式)
堆栈详解（数据与内存中的存储方式） char* r = "hello word!";char b[]="hello word!"*r = 'w';*b='w';其实应该是语法错误，可是VC++6.0没有警告或者错误，r指向的是文字常量区，此区域是编译的时候确定的，并且程序结束的时候自动释放的，*r = 'w';企图修改文字常量区引起错误,b的区别在于其空间是在栈上分配的，因此没有错误。const char* r = "hello word!";*r = 'w';一个由 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\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下，栈的
JVM内存分配(栈堆)与JVM回收机制
Java 中的堆和栈 简单的说： Java把内存划分成两种：一种是栈内存，一种是堆内存。 在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。 当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。 堆内存用来存放由new创建的对象和数组。 在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。 在堆中产生了一个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。 引用变量就相当于是为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。 具体的说： 栈与堆都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。 Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。 栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量（,int, short, long, byte, float, double, boolean, char）和对象句柄。 栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义： int a = 3; int b = 3； 编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找栈中是否有3这个值，如果没找到，就将3存放进来，然后将a指向3。接着处理int b = 3；在创建完b的引用变量后，因为在栈中已经有3这个值，便将b直接指向3。这样，就出现了a与b同时均指向3的情况。这时，如果再令a=4；那么编译器会重新搜索栈中是否有4值，如果没有，则将4存放进来，并令a指向4；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b 的值。要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的，因为这种情况a的修改并不会影响到b, 它是由编译器完成的，它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量。 String是一个特殊的包装类数据。可以用： String str = new String("abc"); String str = "abc"; 两种的形式来创建，第一种是用new()来新建对象的，它会在存放于堆中。每调用一次就会创建一个新的对象。 而第二种是先在栈中创建一个对String类的对象引用变量str，然后查找栈中有没有存放"abc"，如果没有，则将"abc"存放进栈，并令str指向”abc”，如果已经有”abc”则直接令 str指向“abc”。 比较类里面的数值是否相等时，用equals()方法；当测试两个包装类的引用是否指向同一个对象时，用==，下面用例子说明上面的理论。 String str1 = "abc"; String str2 = "abc"; System.out.println(str1==str2); //true
一文解析STM32内存管理和堆栈的认知与理解
一文解析STM32内存管理和堆栈的认知与理解 本文主要介绍了STM32内存管理和堆栈的认知与理解，首先介绍的是内存管理的实现原理及分配、释放原理，其次介绍了stm32的存储器结构，最后阐述了堆栈的认知与理解，具体的跟随小编一起来了解一下吧。 STM32内存管理详解内存管理，是指软件运行时对计算机内存资源的分配和使用的技术。其最主要的目的是如何高效，快速的分配，并且在适当的时候释放和回收内存资源。内存管理的实现方法有很多种，他们其实最终都是要实现2 个函数：malloc 和free；malloc 函数用于内存申请，free 函数用于内存释放。 内存管理的实现原理 从上图可以看出，分块式内存管理由内存池和内存管理表两部分组成。内存池被等分为n 块，对应的内存管理表，大小也为n，内存管理表的每一个项对应内存池的一块内存。内存管理表的项值代表的意义为：当该项值为0 的时候，代表对应的内存块未被占用，当该项值非零的时候，代表该项对应的内存块已经被占用，其数值则代表被连续占用的内存块数。比如某项值为10，那么说明包括本项对应的内存块在内，总共分配了10 个内存块给外部的某个指针。内寸分配方向如图所示 到低位地址）即首先从最末端开始找空内存。当内存管理刚初始化的时候，内存表全部清零，表示没有任何内存块被占用。 分配原理 当指针p 调用malloc 申请内存的时候，先判断p 要分配的内存块数（m），然后从第n 项开始，向下查找，直到找到m 块连续的空内存块（即对应内存管理表项为0），然后将这m 个内存管理表项的值都设置为m（标记被占用），最后，把最后的这个空内存块的地址返回指针p，完成一次分配。注意，如果当内存不够的时候（找到最后也没找到连续的m 块空闲内存），则返回NULL 给p，表示分配失败。 释放原理
堆内存与栈内存的区别
一、程序在编译的时候占用的内存分为以下几个部分： 1 、栈区（stack ）—由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限. 2 、堆区（heap ）—亦称动态内存分配.程序在运行的时候用malloc或new申请任意大小的内存，程序员自己负责在适当的时候用free或delete释放内存。动态内存的生存期可以由我们决定，如果我们不释放内存，程序将在最后才释放掉动态内存.但是，良好的编程习惯是：如果某动态内存不再使用，需要将其释放掉，否则，我们认为发生了内存泄漏现象。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表. 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/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本身是在栈中的。
详解堆栈的几种实现方法
详解堆栈的几种实现方法 基本的抽象数据类型（ADT）是编写C程序必要的过程，这类ADT有链表、堆栈、队列和树等，本文主要讲解下堆栈的几种实现方法以及他们的优缺点。 堆栈（stack）的显著特点是后进先出（Last-In First-Out, LIFO），其实现的方法有三种可选方案：静态数组、动态分配的数组、动态分配的链式结构。 静态数组：特点是要求结构的长度固定，而且长度在编译时候就得确定。其优点是结构简单，实现起来方便而不容易出错。而缺点就是不够灵活以及固定长度不容易控制，适用于知道明确长度的场合。 动态数组：特点是长度可以在运行时候才确定以及可以更改原来数组的长度。优点是灵活，缺点是由此会增加程序的复杂性。 链式结构：特点是无长度上线，需要的时候再申请分配内存空间，可最大程度上实现灵活性。缺点是链式结构的链接字段需要消耗一定的内存，在链式结构中访问一个特定元素的效率不如数组。 首先先确定一个堆栈接口的头文件，里面包含了各个方案下的函数原型，放在一起是为了实现程序的模块化以及便于修改。然后再接着分别介绍各个方案的具体实施方法。 堆栈接口stack.h文件代码： [cpp] view plain copy 1 /*** 堆栈模块的接口 stack.h #include
堆栈、栈(stack)和堆(heap)三者的区别
一、预备知识（程序的内存分配） 一个由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 、申请后系统的响应 stack：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报错提示栈溢出。heap：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序。另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小。这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。 2.3、申请大小的限制 stack：在Windows下，栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是
详解堆栈的几种实现方法——C语言版
详解堆栈的几种实现方法——C语言版 基本的抽象数据类型（ADT）是编写C程序必要的过程，这类ADT有链表、堆栈、队列和树等，本文主要讲解下堆栈的几种实现方法以及他们的优缺点。 堆栈（stack）的显著特点是后进先出（Last-In First-Out, LIFO），其实现的方法有三种可选方案：静态数组、动态分配的数组、动态分配的链式结构。 静态数组：特点是要求结构的长度固定，而且长度在编译时候就得确定。其优点是结构简单，实现起来方便而不容易出错。而缺点就是不够灵活以及固定长度不容易控制，适用于知道明确长度的场合。 动态数组：特点是长度可以在运行时候才确定以及可以更改原来数组的长度。优点是灵活，缺点是由此会增加程序的复杂性。 链式结构：特点是无长度上线，需要的时候再申请分配内存空间，可最大程度上实现灵活性。缺点是链式结构的链接字段需要消耗一定的内存，在链式结构中访问一个特定元素的效率不如数组。 首先先确定一个堆栈接口的头文件，里面包含了各个方案下的函数原型，放在一起是为了实现程序的模块化以及便于修改。然后再接着分别介绍各个方案的具体实施方法。 堆栈接口stack.h文件代码： [cpp]view plaincopy 1./* 2.** 堆栈模块的接口 stack.h 3.*/ 4.#include
ARM 堆栈分析
ARM stack backtrace x.yin@https://www.360docs.net/doc/0214778068.html, Jun1,2009
目录目录目录 1前言2 2ARM寄存器和APCS2 2.1ARM寄存器 (2) 2.1.1ARM寄存器的定义 (2) 2.2APCS (3) 2.2.1应用程序和kernel的APCS (3) 2.2.2APCS-32简介 (3) 3示例代码4 3.1代码清单 (4) 3.1.1test.c (4) 3.1.2test.s (4) 4kernel中的函数callback trace6
2ARM寄存器和APCS 1前言 对于每个C语言开发者来说中，内存错误(内存泄漏，内存越界，野指针，空指针等)恐怕是再熟悉不过了。这些错误通常严重级别很高，隐藏很深而且会产生随机错误，即便在很多调试工具的帮助下，为了找到重现的路径，也需要花费大量的时间。对于uClinux来说，情况就更糟糕了，那些在x86上能够导致程序退出的错误，在uClinux 中大多数情况下并不会退出而只是产生奇怪的运行结果.我们知道，这类错误尽管可以在编码时尽量减少却无法做到全部根除，那么，在这类错误产生时，有什么办法能够帮助我们迅速定位呢？此时只能借助kernel了，如果Kernel在应用程序出错时dump出相应的函数调用顺序，那也就离解决问题不远了。 2ARM寄存器和APCS 在了解如何backtrace ARM下应用程序函数调用顺序之前，有必要先了解一下ARM的寄存器和APCS(ARM Procedure Call Standard).以我们的系统为例:?kernel:uClinux-2.4.22-uc0, ?CPU:PT110,ARM7TDMI兼容。 ?gcc:2.95.3 2.1ARM寄存器 2.1.1ARM寄存器的定义 include/asm-armnommu/proc/ptrace.h 1/*this struct defines the way the registers are stored on the 2stack during a system call.*/ 3 4struct pt_regs...{ 5long uregs[18]; 6}; 7 8#define ARM_cpsr uregs[16]/*程序状态寄存器*/ 9#define ARM_pc uregs[15]/*程序计数器下一条将要执行的指令,*/ 10#define ARM_lr uregs[14]/*寄存器，返回地址link*/ 11#define ARM_sp uregs[13]/*栈指针类似于,的x86esp*/ 12#define ARM_ip uregs[12]/*暂存sp没什么大用,*/ 13#define ARM_fp uregs[11]/*栈帧指针类似 于,的x86ebp*/ 14#define ARM_r10uregs[10] 15#define ARM_r9uregs[9] 16#define ARM_r8uregs[8] 17#define ARM_r7uregs[7] 18#define ARM_r6uregs[6] 19#define ARM_r5uregs[5] 20#define ARM_r4uregs[4] 21#define ARM_r3uregs[3] 22#define ARM_r2uregs[2] 23#define ARM_r1uregs[1] 24#define ARM_r0uregs[0] 25#define ARM_ORIG_r0uregs[17]