堆与栈解析

堆与栈解析
堆与栈解析

在进行C/C++编程时需要程序员对内存的了解比较精确,经常使用到的内存有以下几种:

栈:由编译器自动分配和释放,存放函数的参数值、局部变量的值,操作方式类似于数据结构中的栈堆:一般由程序员分配和释放,与数据结构中的堆是两码事,操作方式类似于链表

全局区(静态区):全局变量和静态变量的存储时放在一块的,初始化的全局变量和静态变量在一块区域,未初始化的全局变量和静态变量在一块区域,程序结束后由系统释放

文字常量区:常量字符串

程序代码区:程序的二进制代码

用代码解析:

[cpp]view plaincopyprint?

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

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

3.main()

4.{

5.int b;//栈

6.char s[]="aaa";//栈

7.char *p2;//栈

8.char *p3="bbb";//p3在栈,“bbb”在常量区

9.

10. static int c=0;//全局初始化区

11. p1=(char*)malloc(10);//堆

12. strcpy(p1,"123");//123 在常量区

13.}

14.

区别:

1,栈由系统自动分配和释放,堆由程序员申请并释放

2,只要栈的剩余空间大于所申请的空间,系统就分配,否则,报异常

对于堆,操作系统有一个记录空闲内存地址的链表,当系统收到申请时,会遍历该链表,寻找第一个空间大于所申请空间的堆节点,然后将该节点从空闲区链表中删除,将该节点的空间分配给程序,若是找到的节点地址空间大于申请的大小,系统会把剩余的节点空间重新添加到内存空闲区链表中

3,对与栈,在window下,栈是向低地址扩展的数据结构,是一块连续的区域,栈的大小事2MB,如果申请的空间超过栈的剩余空间,将提示栈溢出

对与堆,是向高地址扩展的数据结构,且不连续,堆的大小受限于计算机系统的虚拟内存,堆获得的空间比较大,也比较灵活

4,申请效率,栈由系统分配,速度快,程序员无法控制。堆由程序员分配,速度慢,容易产生碎片,用起来方便

5,内容,栈在函数调用时,参数由右往左入栈,然后是局部变量,静态变量不入栈出栈时,局部变量先出栈,然后是参数。堆一般用堆的头部用一个字节存放堆的大小,便于delete或者free

对于如下函数:

[cpp]view plaincopyprint?

1.void fun(int param1,int param2,int param3)

2.{

3.int var1=param1;

4.int var2=param2;

5.int var3=param3;

6. {

7.

8. other code;

9.

10. }

11.}

当调用函数时,栈是从高地址向低地址分布,EBP 是栈底指针,ESP是栈顶指针,参数从右往左入栈,先压param3,然后是param2,最后是param3,然后是函数的返回地址入栈,进入函数后函数地址入栈,EBP入栈,然后把ESP值给EBP,再接着是局部变量入栈,即var1入栈,var2入栈,var3入栈,按照声明的顺序存放在EBP-4,EBP-8,EBP-12的位置

函数调用小结:调用一个函数时,先将堆栈原先的基址(EBP)入栈,以保存之前任务的信息。然后将栈顶指针的值赋给EBP,将之前的栈顶作为新的基址(栈底),然后再这个基址上开辟相应的空间用作被调用函数的堆栈。函数返回后,从EBP中可取出之前的ESP值,使栈顶恢复函数调用前的位置;再从恢复后的栈顶可弹出之前的EBP值(已入栈),因为这个值在函数调用前一步被压入堆栈。这样,EBP和ESP就都恢复了调用前的位置,堆栈恢复函数调用前的状态。

计算机算法设计与分析习题和答案解析

《计算机算法设计与分析》习题及答案 一.选择题 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去和数据区,在代码中同样是引用该数的地址。

利用栈实现c语言计算器

栈的应用:C实现简单计算器(表达式的计算) 作为栈的著名应用,表达式的计算可以用下面方法实现: 首先建立两个栈,操作数栈NUM_S和运算符栈OPR_S。 其中,操作数栈用来存储表达式中的操作数;运算符栈用来存储表达式中的运算符。可以用字符‘=’来表示表达式结束符。 自左至右的扫描待处理的表达式,并假设当前扫描到的符号为W,根据不同的符号W 做如下不同的处理: 1.若W为操作数,则将W压入操作数栈NUM_S,且继续扫描下一个字符; 2.若W为运算符,则根据运算符的性质做相应的处理: (0)若符号栈为空,无条件入栈当前指针指向的字符 (1)若w为不大于运算符栈栈顶的运算符,则从操作数栈NUM_S中弹出两个操作数,设先后弹出的操作数为a、b,再从运算符栈 OPR_S中弹出一个运算符,比如为+,然后作运算a+b,并将运算结果压入操作数栈NUM_S。 (2)若w为左括号或者运算符的优先级大于运算符栈栈顶的运算符,则将运算符W 压入运算符栈OPR_S,并继续扫描下一个字符。 (3)若运算符W为右括号,循环操作(设先后弹出的操作数为a、b,再从运算符栈OPR_S中弹出一个运算符,比如为+,然后作运 算a+b, 并将运算结果压入操作数栈NUM_S),直到从运算符栈中弹出第一个左括号。 (4)若运算符W为表达式结束符‘=’,循环操作(设先后弹出的操作数为a、b,再从运算符栈OPR_S中弹出一个运算符,比如为 +,然后作运算a+b, 并将运算结果压入操作数栈NUM_S),直到运算符栈为空为止。此时,操作数栈栈顶元素即为表达式的 值。 ====================================================================== === 举例:计算3+(5-2*3)/4-2= (1)开始栈为空,3入栈,+入栈,(无条件入栈,5入栈,-号优先级比(高,所以-号入栈,2入栈,*优先级比目前栈顶的-号优先级高,所以*入栈,3入栈,接着扫描到)括号,)括号不入栈 | | | | --------- ---------- | 3 | | * | --------- ---------- | 2 | | - |

堆 栈 详 解

堆栈详解及其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语言栈的使用 #include #include #define TRUE 1 #define FALSE 0 #define MAXSIZE 100 #define ERROR 0 typedef int Elemtype; typedef struct { Elemtype data[MAXSIZE]; int top; }SqStack; void InitStack(SqStack *s) {s->top=-1; } int StackEmpty(SqStack *s) { return(s->top==-1?TRUE:FALSE); } int StackFull(SqStack *s) { return(s->top==MAXSIZE-1?TRUE:FALSE);} int Push(SqStack *s,Elemtype e) { if (StackFull(s)) return ERROR; s->top++; s->data[s->top]=e; } int Pop(SqStack *s,Elemtype &e) { if (StackEmpty (s)) return ERROR; e=s->data[s->top]; s->top--; } void Conversion(int N,int r) { SqStack s; int e; InitStack(&s);

while(N!=0) {Push (&s,N%r); N=N/r; } while(!StackEmpty(&s)) { Pop(&s,e); cout<>N; cin>>r; Conversion(N,r); }

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、生长方向不同;

栈的基本操作c语言

#include #include #include //函数结果状态代码 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 //Status 是函数的类型,其值是函数结果状态代码 typedef int Status; typedef int SetElemType; typedef SetElemType ElemType; #include "tou.h" #include #include typedef char SElemType; // 栈的元素类型 #define STACK_INIT_SIZE 100 // 存储空间初始分配量 #define STACKINCREMENT 10 // 存储空间分配增量 // 栈的顺序存储表示P46 typedef struct SqStack { SElemType *base; // 在栈构造之前和销毁之后,base的值为NULL SElemType *top; // 栈顶指针 int stacksize; // 当前已分配的存储空间,以元素为单位 }SqStack; // 顺序栈 // 构造一个空栈S。 int InitStack(SqStack *S) { // 为栈底分配一个指定大小的存储空间 (*S).base = (SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType)); if( !(*S).base ) exit(OVERFLOW); // 存储分配失败 (*S).top = (*S).base; // 栈底与栈顶相同表示一个空栈

堆栈详解(数据与内存中的存储方式)

堆栈详解(数据与内存中的存储方式) 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语言实现一.二叉树操作 二.用栈实现算术表达式求值 课设报告

目录 题目一.二叉树操作(1)二.算术表达式求 (1) 一、课程设计的目的 (1) 二、课程设计的内容和要求 (1) 三、题目一设计过程 (2) 四、题目二设计过程 (6) 五、设计总结 (17) 六、参考文献 (18)

题目一.二叉树操作(1)二.算术表达式求 一、课程设计的目的 本学期我们对《数据结构》这门课程进行了学习。这门课程是一门实践性非常强的课程,为了让大家更好地理解与运用所学知识,提高动手能力,我们进行了此次课程设计实习。这次课程设计不但要求学生掌握《数据结构》中的各方面知识,还要求学生具备一定的C语言基础和编程能力。 (1)题目一的目的: 1、掌握二叉树的概念和性质 2、掌握二叉树的存储结构 3、掌握二叉树的基本操作 (2)题目二的目的: 1、掌握栈的顺序存储结构和链式存储结构 2、掌握栈的先进后出的特点 3、掌握栈的基本运算 二、课程设计的内容和要求 (1)题目一的内容和要求: 1、编写已知二叉树的先序、中序序列,恢复此二叉树的程序 2、编写求二叉树深度的程序 (2)题目二的内容和要求: 1、算术表达式由操作数、运算符和界限符组成。操作数是正整数,运算符为 加减乘除,界限符有左右括号和表达式起始 2、将一个表达式的中缀形式转化为相应的后缀形式 3、依据后缀表达式计算表达式的值

三、题目一设计过程 1、题目分析 现已知一棵二叉树的先序遍历序列和中序遍历序列,依次从先序遍历序列中取结点,由先序序列确定根结点(就是第一个字母),每次取出一个结点就与中序遍历的序列进行比较,当相等的时候,中序遍历序列就被分成以该结点为根的二叉树子树,该结点左部分为左子树,右部分为右子树,直到取完先序列里的所有结点,则二叉树构造完毕(树用链式存储结构存储),用递归实现! 由建好的二叉树,先判断这棵树是否为空,若不为空则找数的左子树,统计它的高度,然后找树的右子树,统计它的高度,比较左子树和右子树的高度,然后返回其中大的那个值加一,则求出数的高度。这里用递归实现! 2、算法描述 main ( )(主函数) 先构造一颗二叉树,初始化为空,用来存储所构造的二叉树,并输入一棵树的先序序列和中序序列,并统计这个序列的长度。然后调用实现功能的函数。 void CreateBiTree(BiTree *T,char *pre,char *in,int len)(由先序序列和中序序列构造二叉树) 根据前序遍历的特点, 知前序序列(pre)的首个元素(pre[0])为根(root), 然后在中序序列(in)中查找此根(pre[0]), 根据中序遍历特点, 知在查找到的根(root) 前边的序列为左子树, 后边的序列为右子树。设根前边有n个元素,则又有, 在前序序列中,紧跟着根(root)的n个元素序列(即pre[1...n]) 为左子树, 在后边的为右子树,而构造左子树问题其实跟构造整个二叉树问题一样,只是此时前序序列为pre[1...n]), 中序序列为in[0...n-1], 分别为原序列的子串, 构造右子树同样。这里用递归实现! int Depth(BiTree T)(求树的深度) 当所给的参数T是NULL时,返回0。说明这个树只有一个叶子节点深度为0,当所给的参数不是NULL时,函数调用自己看看这个参数的左分支是不是NULL,

详解堆栈的几种实现方法

详解堆栈的几种实现方法 基本的抽象数据类型(ADT)是编写C程序必要的过程,这类ADT有链表、堆栈、队列和树等,本文主要讲解下堆栈的几种实现方法以及他们的优缺点。 堆栈(stack)的显著特点是后进先出(Last-In First-Out, LIFO),其实现的方法有三种可选方案:静态数组、动态分配的数组、动态分配的链式结构。 静态数组:特点是要求结构的长度固定,而且长度在编译时候就得确定。其优点是结构简单,实现起来方便而不容易出错。而缺点就是不够灵活以及固定长度不容易控制,适用于知道明确长度的场合。 动态数组:特点是长度可以在运行时候才确定以及可以更改原来数组的长度。优点是灵活,缺点是由此会增加程序的复杂性。 链式结构:特点是无长度上线,需要的时候再申请分配内存空间,可最大程度上实现灵活性。缺点是链式结构的链接字段需要消耗一定的内存,在链式结构中访问一个特定元素的效率不如数组。 首先先确定一个堆栈接口的头文件,里面包含了各个方案下的函数原型,放在一起是为了实现程序的模块化以及便于修改。然后再接着分别介绍各个方案的具体实施方法。 堆栈接口stack.h文件代码: [cpp] view plain copy 1 /*** 堆栈模块的接口 stack.h #include #define STACK_TYPE int /* 堆栈所存储的值的数据类型 */ /*** 函数原型:create_stack ** 创建堆栈,参数指定堆栈可以保存多少个元素。 ** 注意:此函数只适用于动态分配数组形式的堆栈。*/ void create_stack(size_t size);

堆栈、栈(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下,栈是向低地址扩展的数据结构,是一块连续的内存的区域。这句话的意思是

相关文档
最新文档