堆栈和堆的内容和位置是什么？

堆栈是作为执行线程的临时空间留出的内存.调用函数时,会在堆栈顶部为区域变量和一些簿记数据保留一个块.当该函数返回时,该块将变为未使用状态,并可在下次调用函数时使用.堆栈始终以LIFO(后进先出)顺序保留; 最近保留的块始终是要释放的下一个块.这使得跟踪堆栈非常简单; 从堆栈中释放块只不过是调整一个指针.

堆是为动态分配留出的内存.与堆栈不同,堆中的块的分配和释放没有强制模式; 您可以随时分配一个块并随时释放它.这使得在任何给定时间跟踪堆的哪些部分被分配或释放变得更加复杂; 有许多自定义堆分配器可用于调整不同使用模式的堆性能.

每个线程都获得一个堆栈,而应用程序通常只有一个堆(尽管为不同类型的分配设置多个堆并不罕见).

直接回答您的问题:

操作系统在创建线程时为每个系统级线程分配堆栈.通常,语言运行库调用OS来为应用程序分配堆.

堆栈附加到线程,因此当线程退出堆栈时回收.堆通常在应用程序启动时由运行时分配,并在应用程序(技术过程)退出时回收.

创建线程时设置堆栈的大小.堆的大小在应用程序启动时设置,但可以在需要空间时增长(分配器从操作系统请求更多内存).

堆栈更快,因为访问模式使得从中分配和释放内存变得微不足道(指针/整数简单地递增或递减),而堆在分配或释放中涉及更复杂的簿记.此外,堆栈中的每个字节都经常被频繁地重用,这意味着它往往被映射到处理器的缓存,使其非常快.堆的另一个性能损失是堆(主要是全局资源)通常必须是多线程安全的,即每个分配和释放需要 - 通常 - 与程序中的"所有"其他堆访问同步.

明确的示范:

_{图片来源:vikashazrati.wordpress.com}

• 我最后对图表感到困惑.我以为直到看到那张照片才知道.
• 很好的答案 - 但我认为你应该补充一点,当进程启动时由操作系统分配堆栈(假设存在操作系统),它由程序保持内联.这是堆栈更快的另一个原因 - 推送和弹出操作通常是一个机器指令,现代机器可以在一个周期中至少执行3个,而分配或释放堆涉及调用OS代码.
• @Anarelle处理器在有或没有操作系统的情况下运行指令.我心中的一个例子是SNES,它没有API调用,没有我们今天所知的操作系统 - 但它有一个堆栈.在堆栈上分配是在这些系统上的加法和减法,这对于通过从创建它们的函数返回而弹出它们时被破坏的变量很好,但是将其与构造函数相比较,结果不能仅仅是扔掉了.为此,我们需要堆,它与call和return无关.大多数操作系统都有API堆,没有理由自己做
• @JatinShashoo作为字节码解释器的Java运行时增加了一层虚拟化，因此您所指的只是Java应用程序的观点。从操作系统的角度来看，这仅仅是一个堆，Java运行时进程在其中将其某些空间分配为“非堆”内存，以供处理的字节码使用。该OS级堆的其余部分用作存储对象数据的应用程序级堆。
• “堆栈是保留为暂存空间的内存”。凉。但是就Java内存结构而言，它实际上在哪里？它是堆内存/非堆内存/其他（Java内存结构，根据https://betsol.com/2017/06/java-memory-management-for-java-virtual-machine-jvm/）
• The diagram seems to indicate that the local variables on the stack only reference objects on the heap. Is it not possible for local variables to reference objects on the stack also? If I for instance do `int x = 5;` inside a function call in C, is that 5 not stored on the stack?

堆:

• 存储在计算机RAM中就像堆一样.
• 在堆栈上创建的变量将超出范围并自动解除分配.
• 与堆上的变量相比,分配要快得多.
• 使用实际的堆栈数据结构实现.
• 存储本地数据,返回地址,用于参数传递.
• 当使用过多的堆栈时(主要来自无限或太深的递归,非常大的分配),可能会发生堆栈溢出.
• 可以在没有指针的情况下使用在堆栈上创建的数据.
• 如果您确切地知道在编译时需要分配多少数据并且它不是太大,您将使用堆栈.
• 通常在程序启动时已确定最大大小.

堆:

• 像堆栈一样存储在计算机RAM中.
• 在C++中,必须手动销毁堆上的变量,并且永远不会超出范围.该数据被释放与delete,delete[],或free.
• 与堆栈上的变量相比,分配更慢.
• 按需使用以分配程序使用的数据块.
• 当有大量分配和解除分配时,可能会出现碎片.
• 在C++或C中,在堆上创建的数据将由指针指向并分别用new或分配malloc.
• 如果请求分配太大的缓冲区,则可能会出现分配失败.
• 如果您不确切知道运行时需要多少数据,或者需要分配大量数据,则可以使用堆.
• 负责内存泄漏.

例:

int foo()
{
char *pBuffer; //<--nothing allocated yet (excluding the pointer itself, which is allocated here on the stack).
bool b = true; // Allocated on the stack.
if(b)
{
//Create 500 bytes on the stack
char buffer[500];
//Create 500 bytes on the heap
pBuffer = new char[500];
}//<-- buffer is deallocated here, pBuffer is not
}//<--- oops there's a memory leak, I should have called delete[] pBuffer;

• @Brian你应该解释为什么*buffer []和pBuffer指针是在堆栈上创建的,以及为什么在堆上创建pBuffer的数据.我认为有些人可能会对你的答案感到困惑,因为他们可能认为程序是专门指示在堆栈上分配内存而不是堆,但事实并非如此.是因为Buffer是值类型而pBuffer是引用类型吗？
• 一种常见的误解是`C`语言,由`C99`语言标准定义(可从http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf获得) ,需要一个"堆栈".实际上,"堆栈"这个词甚至没有出现在标准中.这个回答语句wrt/to`C`的堆栈用法一般都是正确的,但语言绝不需要.有关更多信息,请参阅http://www.knosof.co.uk/cbook/cbook.html,特别是如何在奇球结构上实现`C`,例如http://en.wikipedia.org/wiki/ Burroughs_large_systems
• "负责内存泄漏" - 堆不负责内存泄漏!Lazy/Forgetful/ex-java编码员/编码员谁不给垃圾!
• 指针pBuffer和b的值位于堆栈上,并且很可能在函数的入口处分配.根据编译器,缓冲区也可以在功能入口处分配.
• @Remover:没有指针包含一个地址,它可以指向堆或堆栈上的某些内容.new,malloc和类似于malloc的其他一些函数在堆上分配并返回已分配的内存的地址.你为什么要在堆上分配？这样你的记忆就不会超出范围,直到你想要它为止.
• 关于范围和分配的注释也是错误的 - Scope根本没有连接到堆栈或堆.*必须手动销毁堆上的变量,并且永远不会超出范围.*不正确; 如果说"当引用它们的变量超出范围时,不会释放堆上的数据更正确.由你(或垃圾收集器)来释放它们.
• @Brian我是新手,我对这个话题有疑问.如果我以某种方式声明一个变量,它是在堆栈上还是在堆上？声明的变量没有其他地方存在？静态成员怎么样？
• 我认为,因为在堆栈上分配一些东西只是递增堆栈指针的顶部.对于堆,您需要找到足够大的可用位置.虽然不确定,但我知道堆栈更快,更快.
• 读它的其他答案"计算机内存只是一系列地址;"堆"和"堆栈"是编译器的发明." 这是真的吗？
• 堆栈和堆是显然用真实数据结构创建的抽象.但是你缺少一点,谁创建并负责堆栈和堆的生命周期？是操作系统吗？这些堆栈和堆究竟是如何创建的？如果您不想直接在答案中包含此信息,是否可以链接到书籍或来源,详细说明？此外,您的枚举可能会更好,枚举点可以更合理的方式排序!

最重要的一点是堆和堆栈是可以分配内存的方式的通用术语.它们可以以多种不同的方式实现,并且这些术语适用于基本概念.

• 堆栈的简单性在于您不需要维护包含已分配内存的每个部分的记录的表; 您需要的唯一状态信息是指向堆栈末尾的单个指针.要分配和取消分配,只需递增和递减该单个指针即可.注意:有时可以实现堆栈从一部分内存的顶部开始并向下延伸而不是向上扩展.

• 堆分配需要维护已分配内存和不分配内存的完整记录,以及减少碎片的一些开销维护,找到足以满足请求大小的连续内存段,等等.内存可以在任何时候释放,留下自由空间.有时,内存分配器将执行维护任务,例如通过移动已分配的内存来进行内存碎片整理,或者进行垃圾收集 - 在运行时识别内存不再在范围内并解除分配时.

这些图像应该可以很好地描述在堆栈和堆中分配和释放内存的两种方法.百胜!

• 如前所述,堆和堆栈是通用术语,可以通过多种方式实现.计算机程序通常具有称为调用堆栈的堆栈,其存储与当前函数相关的信息,例如指向调用它的任何函数的指针,以及任何局部变量.因为函数调用其他函数然后返回,所以堆栈增大和缩小以保持来自调用堆栈中的函数的信息.程序实际上没有运行时控制权; 它取决于编程语言,操作系统甚至系统架构.

  堆是一个通用术语,用于动态和随机分配的任何内存; 即无序.内存通常由OS分配,应用程序调用API函数来执行此分配.管理动态分配的内存需要相当大的开销,这通常由操作系统处理.

• 调用堆栈是一种低级概念,它与编程意义上的"范围"无关.如果您反汇编某些代码,您将看到对堆栈部分的相对指针样式引用,但就更高级别的语言而言,该语言强加了自己的范围规则.但是,堆栈的一个重要方面是,一旦函数返回,该函数的任何本地函数都会立即从堆栈中释放出来.考虑到编程语言的工作原理,它的工作方式与预期的方式相同.在堆中,它也很难定义.范围是操作系统公开的内容,但是您的编程语言可能会添加有关应用程序中"范围"的规则.处理器体系结构和OS使用虚拟寻址,处理器将虚拟寻址转换为物理地址,并存在页面错误等.它们跟踪哪些页面属于哪些应用程序.但是,您永远不必担心这一点,因为您只需使用编程语言用于分配和释放内存的任何方法,并检查错误(如果分配/释放因任何原因失败).

• 同样,它取决于语言,编译器,操作系统和体系结构.堆栈通常是预先分配的,因为根据定义它必须是连续的内存(更多内容在最后一段中).语言编译器或OS确定其大小.你不会在堆栈上存储大量的数据,所以它应该足够大,永远不应该被完全使用,除非出现不必要的无限递归(因此,"堆栈溢出")或其他不寻常的编程决策.

  堆是可以动态分配的任何东西的通用术语.根据您的观察方式,它会不断变化.在现代处理器和操作系统中,它的工作方式无论如何都是非常抽象的,所以你通常不需要担心它如何深入工作,除了(在它允许你的语言中)你不能使用的内存你尚未分配或已释放的记忆.

• 堆栈更快,因为所有可用内存始终是连续的.不需要维护所有可用内存段的列表,只需要指向当前堆栈顶部的单个指针.为此,编译器通常将此指针存储在特殊的快速寄存器中.更重要的是,堆栈上的后续操作通常集中在非常靠近的内存区域,这非常低的水平有利于处理器片上高速缓存的优化.

• 大卫我不同意这是一个好的形象,或者"下推堆栈"是一个很好的术语来说明这个概念.当您向堆栈添加内容时,堆栈*的其他内容不会被按下*,它们会保留在原来的位置.
• 具体来说,您说在堆栈上分配了"静态分配的局部变量".实际上它们是在数据段中分配的.只有自动分配的变量(包括大多数但不是所有局部变量以及像值而不是通过引用传递的函数参数之类的东西)都会在堆栈上分配.
• 我刚刚意识到你是对的 - 在C中,*静态分配*是它自己独立的东西而不是任何不是*动态*的术语.我编辑了我的答案,谢谢.
• 这个答案包含一个大错误.静态变量未在堆栈上分配.请参阅我的回答[链接] http://stackoverflow.com/a/13326916/1763801以获得澄清.您将"自动"变量与"静态"变量等同起来,但它们完全不相同
• 它不仅仅是C. Java,Pascal,Python和其他许多人都有静态与自动与动态分配的概念.说"静态分配"在任何地方都意味着同样的事情.在任何语言中静态分配都意味着"不动态".您希望术语"自动"分配您正在描述的内容(即堆栈中的内容).
• @Timeless堆栈和堆是分配内存的两种常用方法，几乎​​可以在任何计算平台上找到。也就是说，内存分配中还存在其他概念，其中一些在较低（物理到虚拟内存映射）或较高（数据结构）级别上运行。

(我已经从另一个或多或少是这个问题的问题中提出了这个答案.)

您的问题的答案是特定于实现的,并且可能因编译器和处理器体系结构而异.但是,这是一个简化的解释.

• 堆栈和堆都是从底层操作系统分配的内存区域(通常是按需映射到物理内存的虚拟内存).
• 在多线程环境中,每个线程都有自己完全独立的堆栈,但它们将共享堆.必须在堆上控制并发访问,并且不能在堆栈上进行访问.

堆

• 堆包含已使用和可用块的链接列表.通过从其中一个空闲块创建合适的块来满足堆上的新分配(通过new或malloc).这需要更新堆上的块列表.该元信息在堆上块也存储在堆上经常在小范围只是在每个块的前面.
• 随着堆增长,新块通常从较低地址分配给较高地址.因此,您可以将堆视为一堆内存块,随着内存的分配而增大.如果堆对于分配而言太小,则通常可以通过从底层操作系统获取更多内存来增加大小.
• 分配和释放许多小块可能使堆处于这样的状态:在所使用的块之间散布有大量小的空闲块.分配大块的请求可能会失败,因为即使可用块的组合大小足够大,也没有任何空闲块足够大以满足分配请求.这称为堆碎片.
• 当释放与空闲块相邻的使用块时,可以将新的空闲块与相邻的空闲块合并以创建更大的空闲块,从而有效地减少堆的碎片.

堆栈

• 堆栈通常与CPU上的特殊寄存器紧密串联工作,命名为堆栈指针.最初,堆栈指针指向堆栈的顶部(堆栈中的最高地址).
• CPU具有将值推入堆栈并从堆栈弹回的特殊指令.每次推送都将值存储在堆栈指针的当前位置,并减少堆栈指针.甲弹出检索值由堆栈指针所指向,然后增加堆栈指针(不通过这样的事实相混淆增加一个值到堆栈降低堆栈指针和去除的值增加了.请注意,堆栈增长到底部).存储和检索的值是CPU寄存器的值.
• 当调用函数时,CPU使用特殊指令来推送当前指令指针,即在堆栈上执行的代码的地址.然后CPU通过将指令指针设置为被调用函数的地址来跳转到该函数.稍后,当函数返回时,旧的指令指针从堆栈中弹出,并且在调用函数之后的代码处继续执行.
• 输入函数时,堆栈指针会减少,以便在堆栈上为本地(自动)变量分配更多空间.如果函数有一个本地32位变量,则在堆栈上留出四个字节.当函数返回时,堆栈指针被移回以释放分配的区域.
• 如果函数有参数,则在调用函数之前将它们压入堆栈.然后,函数中的代码能够从当前堆栈指针向上导航堆栈以找到这些值.
• 嵌套函数调用就像魅力一样.每个新调用都将分配函数参数,返回地址和局部变量的空间,这些激活记录可以堆叠用于嵌套调用,并在函数返回时以正确的方式展开.
• 由于堆栈是有限的内存块,因此可以通过调用太多嵌套函数和/或为局部变量分配太多空间来导致堆栈溢出.通常,用于堆栈的存储区域的设置方式是在堆栈的底部(最低地址)下写入将触发CPU中的陷阱或异常.然后,运行时可以捕获此异常情况并将其转换为某种堆栈溢出异常.

不,函数的激活记录(即本地或自动变量)在堆栈上分配,不仅用于存储这些变量,还用于跟踪嵌套函数调用.

如何管理堆实际上取决于运行时环境.C使用malloc和C++使用new,但许多其他语言都有垃圾收集.

但是,堆栈是与处理器架构紧密相关的更低级别的功能.当没有足够的空间时增加堆不是太难,因为它可以在处理堆的库调用中实现.但是,堆栈的增长通常是不可能的,因为只有在为时已晚时才发现堆栈溢出; 并且关闭执行线程是唯一可行的选择.

• @Martin - 一个非常好的答案/解释,而不是更抽象的答案.显示用于vis函数调用的堆栈指针/寄存器的示例汇编程序将更具说明性.
• 这个答案在我看来是最好的,因为它帮助我理解了返回语句究竟是什么以及它与我偶尔遇到的这个"返回地址"有什么关系,将函数推入堆栈意味着什么,以及为什么函数被压入堆栈.很棒的答案!
• 每个引用类型都是值类型的组合(int,string等).正如所说的那样,值类型存储在堆栈中,而不是它们作为引用类型的一部分时的工作方式.
• 在我看来,这是最好的,即提到堆/堆栈是*非常*特定于实现.其他答案假定有很多关于语言和环境/操作系统的事情.+1
• 你是什​​么意思"函数中的代码然后能够从当前堆栈指针向上导航堆栈以找到这些值." ？你能详细说明吗？

在以下C#代码中

public void Method1()
{
int i = 4;
int y = 2;
class1 cls1 = new class1();
}

以下是内存的管理方式

Local Variables只要函数调用进入堆栈,只需要持续.堆用于变量,我们事先并不知道它们的生命周期,但我们希望它们可以持续一段时间.在大多数语言中,如果我们想要将它存储在堆栈中,那么在编译时我们知道变量的大小是至关重要的.

对象(在更新它们时大小不同)会在堆上进行,因为我们在创建时不知道它们将持续多长时间.在许多语言中,堆被垃圾收集以查找不再具有任何引用的对象(例如cls1对象).

在Java中,大多数对象直接进入堆.在像C/C++这样的语言中,当你不处理指针时,结构和类通常可以保留在堆栈中.

更多信息可以在这里找到:

堆栈和堆内存分配之间的区别«timmurphy.org

和这里:

在堆栈和堆上创建对象

本文是上图的来源:六个重要的.NET概念:堆栈,堆,值类型,引用类型,装箱和拆箱 - CodeProject

但请注意,它可能包含一些不准确之处.

• 这是不正确的.我和cls不是"静态"变量.它们被称为"本地"或"自动"变量.这是一个非常重要的区别.有关说明,请参见[link] http://stackoverflow.com/a/13326916/1763801
• 编写该代码项目文章的人也不知道他在说什么.例如,他说"原始人需要静态类型记忆",这完全是不真实的.没有什么能阻止你动态地在堆中分配原语,只需写一些类似"int array [] = new int [num]"的东西,以及在.NET中动态分配的原语.这只是几个不准确之一.
• 我引用"静态项目......进入堆栈".这只是错误的.静态项目进入数据段,自动项目进入堆栈.
• 我没有说他们是静态_variables_.我说int和cls1是静态_items_.他们的内存是静态分配的,因此它们会进入堆栈.这与需要动态内存分配的对象形成对比,因此动态内存分配在堆上.
• 我编辑了你的帖子,因为你对堆栈和堆中的内容犯了严重的技术错误.

堆栈
当你调用一个函数时,该函数的参数加上一些其他开销被放在堆栈上.一些信息(例如返回的地方)也存储在那里.在函数内部声明变量时,该变量也会在堆栈中分配.

取消分配堆栈非常简单,因为您总是按照分配的相反顺序解除分配.输入函数时会添加堆栈内容,退出时会删除相应的数据.这意味着您倾向于保持在堆栈的一个小区域内,除非您调用许多调用许多其他函数的函数(或创建递归解决方案).

该堆
的堆是,你把你的飞行创建数据的通用名称.如果您不知道程序将创建多少太空飞船,您可能会使用新的(或malloc或等效的)运算符来创建每个太空飞船.这种分配将持续一段时间,因此我们很可能会以与创建它们不同的顺序释放事物.

因此,堆要复杂得多,因为最终存在未使用的内存区域与内存被分段的块交织.找到所需大小的空闲内存是一个难题.这就是应该避免堆的原因(虽然它仍然经常使用).

实现
堆栈和堆的实现通常都是运行时/操作系统.通常,性能至关重要的游戏和其他应用程序会创建自己的内存解决方案,从堆中获取大量内存,然后在内部将其清除,以避免依赖操作系统获取内存.

这只有在你的内存使用量与标准有很大不同的情况下才有用 - 即对于你在一个巨大的操作中加载一个级别并且可以在另一个巨大的操作中丢掉所有内存的游戏.

内存中的物理位置
由于称为虚拟内存的技术使您的程序认为您可以访问物理数据位于其他位置的某个地址(即使在硬盘上!),因此与您的想法相关性较低.当您的调用树变得更深时,您获得的堆栈地址会逐渐增加.堆的地址是不可预测的(即特定于implimentation),坦率地说并不重要.

• 建议避免使用堆非常强大.现代系统具有良好的堆管理器,现代动态语言广泛使用堆(没有程序员真正担心它).我会说使用堆,但是使用手动分配器,不要忘记释放!
• 如果可以使用堆栈或堆,请使用堆栈.如果你不能使用堆栈,真的别无选择.我使用了很多,当然使用std :: vector或类似命中堆.对于新手来说,你可以避免堆积,因为堆栈非常简单!
• 好点@JonnoHampson - 虽然你提出了一个有效的观点，但我认为如果你使用 GC 的“高级语言”工作，你可能根本不关心内存分配机制 - 所以不要甚至关心堆栈和堆是什么。

澄清一下,这个答案有不正确的信息(托马斯在评论后修正了他的答案,很酷:)).其他答案只是避免解释静态分配的含义.因此,我将解释三种主要的分配形式以及它们通常如何与下面的堆,堆栈和数据段相关联.我还将展示C/C++和Python中的一些示例,以帮助人们理解.

"静态"(AKA静态分配)变量未在堆栈上分配.不要这么认为 - 许多人只是因为"静态"听起来很像"堆叠".它们实际上既不存在于堆栈中,也不存在于堆中.这是所谓的数据段的一部分.

但是,通常最好考虑" 范围 "和" 生命周期 "而不是"堆栈"和"堆".

范围是指代码的哪些部分可以访问变量.通常我们会考虑局部范围(只能通过当前函数访问)与全局范围(可以在任何地方访问),尽管范围可能变得更加复杂.

生命周期是指在程序执行期间分配和解除分配变量的时间.通常我们会想到静态分配(变量将持续整个程序的持续时间,使其对于在多个函数调用中存储相同的信息很有用)与自动分配(变量仅在单个函数调用期间持续存在,使其对于存储仅在函数期间使用的信息,并且一旦完成就可以丢弃)与动态分配(变量的持续时间在运行时定义,而不是像静态或自动一样的编译时).

尽管大多数编译器和解释器在使用堆栈,堆等方面类似地实现了这种行为,但只要行为正确,编译器有时可能会破坏这些约定.例如,由于优化,局部变量可能只存在于寄存器中或被完全删除,即使堆栈中存在大多数局部变量.正如在一些注释中指出的那样,你可以自由地实现一个甚至不使用堆栈或堆的编译器,而是使用其他一些存储机制(很少做,因为堆栈和堆很适合这个).

我将提供一些简单的带注释的C代码来说明所有这些.学习的最佳方法是在调试器下运行程序并观察行为.如果你更喜欢阅读python,请跳到答案结尾:)

// Statically allocated in the data segment when the program/DLL is first loaded
// Deallocated when the program/DLL exits
// scope - can be accessed from anywhere in the code
int someGlobalVariable;
// Statically allocated in the data segment when the program is first loaded
// Deallocated when the program/DLL exits
// scope - can be accessed from anywhere in this particular code file
static int someStaticVariable;
// "someArgument" is allocated on the stack each time MyFunction is called
// "someArgument" is deallocated when MyFunction returns
// scope - can be accessed only within MyFunction()
void MyFunction(int someArgument) {
// Statically allocated in the data segment when the program is first loaded
// Deallocated when the program/DLL exits
// scope - can be accessed only within MyFunction()
static int someLocalStaticVariable;
// Allocated on the stack each time MyFunction is called
// Deallocated when MyFunction returns
// scope - can be accessed only within MyFunction()
int someLocalVariable;
// A *pointer* is allocated on the stack each time MyFunction is called
// This pointer is deallocated when MyFunction returns
// scope - the pointer can be accessed only within MyFunction()
int* someDynamicVariable;
// This line causes space for an integer to be allocated in the heap
// when this line is executed. Note this is not at the beginning of
// the call to MyFunction(), like the automatic variables
// scope - only code within MyFunction() can access this space
// *through this particular variable*.
// However, if you pass the address somewhere else, that code
// can access it too
someDynamicVariable = new int;
// This line deallocates the space for the integer in the heap.
// If we did not write it, the memory would be "leaked".
// Note a fundamental difference between the stack and heap
// the heap must be managed. The stack is managed for us.
delete someDynamicVariable;
// In other cases, instead of deallocating this heap space you
// might store the address somewhere more permanent to use later.
// Some languages even take care of deallocation for you... but
// always it needs to be taken care of at runtime by some mechanism.
// When the function returns, someArgument, someLocalVariable
// and the pointer someDynamicVariable are deallocated.
// The space pointed to by someDynamicVariable was already
// deallocated prior to returning.
return;
}
// Note that someGlobalVariable, someStaticVariable and
// someLocalStaticVariable continue to exist, and are not
// deallocated until the program exits.

为什么区分生命周期和范围很重要的一个特别尖锐的例子是变量可以具有局部范围但是具有静态生命周期 - 例如,上面的代码示例中的"someLocalStaticVariable".这些变量可以使我们共同但非正式的命名习惯非常混乱.例如,当我们说" 本地 "时,我们通常意味着" 本地范围自动分配变量 ",当我们说全局时,我们通常表示" 全局范围的静态分配变量 ".不幸的是,当涉及到" 文件范围静态分配变量 " 这样的事情时,很多人只会说......" 嗯??? ".

C/C++中的一些语法选择加剧了这个问题 - 例如,由于下面显示的语法,许多人认为全局变量不是"静态的".

int var1; // Has global scope and static allocation
static int var2; // Has file scope and static allocation
int main() {return 0;}

请注意,在上面的声明中放置关键字"static"可以防止var2具有全局范围.然而,全局var1具有静态分配.这不直观!出于这个原因,我尝试在描述范围时从不使用"静态"一词,而是说"文件"或"文件限制"范围.然而,许多人使用短语"静态"或"静态范围"来描述只能从一个代码文件访问的变量.在生命周期的上下文中,"static" 总是表示变量在程序启动时分配,并在程序退出时释放.

有些人认为这些概念是特定于C/C++的.他们不是.例如,下面的Python示例说明了所有三种类型的分配(在解释语言中可能存在一些细微差别,我不会在这里讨论).

from datetime import datetime
class Animal:
_FavoriteFood = 'Undefined' # _FavoriteFood is statically allocated
def PetAnimal(self):
curTime = datetime.time(datetime.now()) # curTime is automatically allocatedion
print("Thank you for petting me. But it's " + str(curTime) + ", you should feed me. My favorite food is " + self._FavoriteFood)
class Cat(Animal):
_FavoriteFood = 'tuna' # Note since we override, Cat class has its own statically allocated _FavoriteFood variable, different from Animal's
class Dog(Animal):
_FavoriteFood = 'steak' # Likewise, the Dog class gets its own static variable. Important to note - this one static variable is shared among all instances of Dog, hence it is not dynamic!
if __name__ == "__main__":
whiskers = Cat() # Dynamically allocated
fido = Dog() # Dynamically allocated
rinTinTin = Dog() # Dynamically allocated
whiskers.PetAnimal()
fido.PetAnimal()
rinTinTin.PetAnimal()
Dog._FavoriteFood = 'milkbones'
whiskers.PetAnimal()
fido.PetAnimal()
rinTinTin.PetAnimal()
# Output is:
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is tuna
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is steak
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is steak
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is tuna
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is milkbones
# Thank you for petting me. But it's 13:05:02.256000, you should feed me. My favorite food is milkbones

其他人已经很好地回答了广泛的笔触,所以我会提出一些细节.

void myfunction()
{
char big[10000000];
// Do something that only uses for first 1K of big 99% of the time.
}

其他人直接回答了你的问题,但在尝试理解堆栈和堆时,我认为考虑传统UNIX进程的内存布局(没有线程和mmap()基于分配器)是有帮助的.该内存管理词汇网页都有此内存布局的示意图.

堆栈和堆传统上位于进程的虚拟地址空间的两端.堆栈在访问时会自动增长,最大可达内核设置的大小(可以调整setrlimit(RLIMIT_STACK, ...)).当内存分配器调用brk()或sbrk()系统调用时,堆会增长,将更多页面的物理内存映射到进程的虚拟地址空间.

在没有虚拟内存的系统中,例如某些嵌入式系统,通常会应用相同的基本布局,但堆栈和堆的大小是固定的.但是,在其他嵌入式系统(例如基于Microchip PIC单片机的系统)中,程序堆栈是一个单独的内存块,无法通过数据移动指令寻址,只能通过程序流指令间接修改或读取(调用,返回等).其他架构(如Intel Itanium处理器)具有多个堆栈.从这个意义上说,堆栈是CPU架构的一个元素.

堆栈是内存的一部分,可以通过几个关键的汇编语言指令来操作,例如'pop'(从堆栈中删除并返回一个值)和'push'(将值推送到堆栈),还可以调用(调用子程序 - 这会推送地址返回堆栈)并返回(从子程序返回 - 这会弹出堆栈中的地址并跳转到它).它是堆栈指针寄存器下面的内存区域,可以根据需要进行设置.堆栈还用于将参数传递给子例程,也用于在调用子例程之前保留寄存器中的值.

堆是操作系统给应用程序的内存的一部分,通常通过类似malloc的系统调用.在现代操作系统上,此内存是一组只有调用进程才能访问的页面.

堆栈的大小在运行时确定,并且通常在程序启动后不会增长.在C程序中,堆栈需要足够大以容纳每个函数中声明的每个变量.堆将根据需要动态增长,但操作系统最终会进行调用(它通常会使堆的增长超过malloc请求的值,因此至少某些未来的malloc将不需要返回到内核获得更多内存.此行为通常是可自定义的)

因为你在启动程序之前已经分配了堆栈,所以在使用堆栈之前你永远不需要malloc,所以这是一个小优势.在实践中,很难预测具有虚拟内存子系统的现代操作系统的速度和速度会有多快,因为页面的实现方式和存储位置是实现细节.

• 此外值得一提的是,intel大大优化了堆栈访问,尤其是预测从函数返回的位置.

我想很多其他人在这件事上给了你大致正确的答案.

然而,遗漏的一个细节是"堆"实际上可能被称为"免费商店".这种区别的原因是原始的免费存储是使用称为"二项式堆"的数据结构实现的.出于这个原因,从malloc()/ free()的早期实现中分配是从堆中分配的.然而,在这个现代,大多数免费商店都使用非二维堆的非常精细的数据结构来实现.

• 另一个挑剔 - 大多数答案(轻轻地)暗示"C"语言需要使用"堆栈".这是一种常见的误解,尽管它是(迄今为止)实现`C99 6.2.4自动存储持续时间对象'(变量)的主导范例.实际上,"堆栈"这个词甚至没有出现在`C99`语言标准中:http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf

什么是堆栈？

堆叠是一堆物体,通常是整齐排列的物体.

什么是堆？

堆是随意堆积的不整齐的东西.

两者一起

哪个更快 - 堆栈还是堆？为什么？

对于刚接触编程的人来说,使用堆栈可能是一个好主意,因为它更容易.
由于堆栈很小,因此当您确切知道数据需要多少内存时,或者如果您知道数据的大小非常小时,则需要使用它.
当您知道数据需要大量内存时,最好使用堆,或者您只是不确定需要多少内存(例如动态数组).

Java内存模型

堆栈是存储局部变量(包括方法参数)的存储区域.对于对象变量,这些仅仅是对堆上实际对象的引用(指针).
每次实例化一个对象时,都会留出一大堆堆内存来保存该对象的数据(状态).由于对象可以包含其他对象,因此某些数据实际上可以保存对这些嵌套对象的引用.

你可以用堆栈做一些有趣的事情.例如,你有像alloca这样的函数(假设你可以通过关于它的使用的大量警告),这是一种malloc,它专门使用堆栈而不是堆来存储.

也就是说,基于堆栈的内存错误是我经历过的最糟糕的错误.如果使用堆内存,并且超出了已分配块的范围,则有可能触发段错误.(不是100%:你的块可能偶然与你先前分配的另一个块连续.)但是由于在堆栈上创建的变量总是相互连续,因此写出越界可以改变另一个变量的值.我了解到,每当我觉得我的程序已经停止遵守逻辑定律时,它可能就是缓冲区溢出.

简单地说,堆栈是创建局部变量的地方.此外,每次调用子程序时,程序计数器(指向下一个机器指令的指针)和任何重要的寄存器,有时参数都会被压入堆栈.然后子程序中的任何局部变量被压入堆栈(并从那里使用).当子程序结束时,所有东西都会从堆栈中弹出.PC和寄存器数据在弹出时会被放回原处,因此您的程序可以顺利进行.

堆是内存区域动态内存分配由(显式"新"或"分配"调用)组成.它是一种特殊的数据结构,可以跟踪不同大小的内存块及其分配状态.

在"经典"系统中,RAM被布置成使得堆栈指针从内存的底部开始,堆指针从顶部开始,并且它们朝向彼此增长.如果它们重叠,则表示RAM不足.但这不适用于现代多线程操作系统.每个线程都必须有自己的堆栈,这些堆栈可以动态创建.

来自WikiAnwser.

堆

当函数或方法调用另一个函数,该函数又调用另一个函数等时,所有这些函数的执行将保持挂起,直到最后一个函数返回其值.

这个挂起函数调用链是堆栈,因为堆栈中的元素(函数调用)彼此依赖.

在异常处理和线程执行中,堆栈很重要.

堆

堆只是程序用来存储变量的内存.堆的元素(变量)彼此之间没有依赖关系,并且可以随时随机访问.

堆

• 非常快速的访问
• 不必显式取消分配变量
• 空间由CPU有效管理,内存不会碎片化
• 仅限局部变量
• 限制堆栈大小(取决于操作系统)
• 变量无法调整大小

堆

• 可以全局访问变量
• 内存大小没有限制
• (相对)访问速度较慢
• 无法保证有效利用空间,随着时间的推移,内存可能会随着内存块的分配而变得碎片化,然后被释放
• 你必须管理内存(你负责分配和释放变量)
• 可以使用realloc()调整变量的大小

简而言之

堆栈用于静态内存分配,堆用于动态内存分配,两者都存储在计算机的RAM中.

详细地

堆栈

堆栈是一个"LIFO"(后进先出)数据结构,由CPU非常密切地管理和优化.每次函数声明一个新变量时,它都会被"推"到堆栈上.然后每次函数退出时,该函数推送到堆栈的所有变量都被释放(也就是说,它们被删除).一旦释放了堆栈变量,该内存区域就可用于其他堆栈变量.

使用堆栈存储变量的优点是可以为您管理内存.您不必手动分配内存,也不必在不再需要时释放内存.更重要的是,因为CPU如此高效地组织堆栈内存,读取和写入堆栈变量的速度非常快.

更多信息可以在这里找到.

堆

堆是计算机内存的一个区域,不会自动为您管理,并且不受CPU的严格管理.它是一个更自由浮动的内存区域(并且更大).要在堆上分配内存,必须使用malloc()或calloc(),它们是内置的C函数.一旦你在堆上分配了内存,你就有责任使用free()在你不再需要它时解除分配该内存.

如果您没有这样做,您的程序将具有所谓的内存泄漏.也就是说,堆上的内存仍然会被搁置(并且不会被其他进程使用).正如我们将在调试部分中看到的,有一个名为Valgrind的工具可以帮助您检测内存泄漏.

与堆栈不同,堆对可变大小没有大小限制(除了计算机明显的物理限制).堆内存的读取和写入速度稍慢,因为必须使用指针来访问堆上的内存.我们将很快讨论指针.

与堆栈不同,堆上创建的变量可由程序中的任何位置的任何函数访问.堆变量本质上是全局的.

更多信息可以在这里找到.

在堆栈上分配的变量直接存储到存储器中,并且对该存储器的访问非常快,并且在编译程序时处理其分配.当函数或方法调用另一个函数,该函数又调用另一个函数等时,所有这些函数的执行将保持挂起,直到最后一个函数返回其值.堆栈始终以LIFO顺序保留,最近保留的块始终是要释放的下一个块.这使得跟踪堆栈非常简单,从堆栈中释放块只不过是调整一个指针.

在堆上分配的变量在运行时分配了内存并且访问此内存有点慢,但堆大小仅受虚拟内存大小的限制.堆的元素彼此之间没有依赖关系,并且可以随时随机访问.您可以随时分配一个块并随时释放它.这使得在任何给定时间跟踪堆的哪些部分被分配或释放变得更加复杂.

如果您确切地知道在编译之前需要分配多少数据,那么您可以使用堆栈,并且它不会太大.如果您不确切知道运行时需要多少数据,或者需要分配大量数据,则可以使用堆.

在多线程情况下,每个线程都有自己完全独立的堆栈,但它们将共享堆.堆栈是特定于线程的,堆是特定于应用程序的.在异常处理和线程执行中,堆栈很重要.

每个线程都获得一个堆栈,而应用程序通常只有一个堆(尽管为不同类型的分配设置多个堆并不罕见).

在运行时,如果应用程序需要更多堆,它可以从空闲内存分配内存,如果堆栈需要内存,它可以从应用程序的空闲内存分配内存中分配内存.

甚至,这里和这里给出了更多细节.

现在来看你的问题的答案.

操作系统在创建线程时为每个系统级线程分配堆栈.通常,语言运行库调用OS来为应用程序分配堆.

更多信息可以在这里找到.

已经在顶部给出.

更多信息可以在这里找到.

创建线程时,OS的大小由OS设置.堆的大小在应用程序启动时设置,但它可以在需要空间时增长(分配器从操作系统请求更多内存).

堆栈分配要快得多,因为它真正做的就是移动堆栈指针.使用内存池,您可以从堆分配中获得可比较的性能,但这会带来轻微的复杂性和自身的麻烦.

此外,堆栈与堆不仅是性能考虑因素; 它还告诉你很多关于对象的预期寿命.

细节可以在这里找到.

好吧,简单而言之,它们意味着有序而不是有序 ......!

堆栈:在堆栈项目中,事物处于彼此的顶部,意味着要更快,更高效地处理!...

所以总有一个索引指向特定项目,处理速度也会更快,项目之间也存在关联!...

堆:没有订单,处理速度会慢,价值会混乱,没有特定的订单或索引......有随机的,它们之间没有关系......所以执行和使用时间可能会有所不同......

我还创建了下面的图像,以显示它们的外观:

在20世纪80年代,UNIX像兔子一样传播,大公司自己推销.埃克森只有一个和历史上失去的几十个品牌一样.如何记忆是由许多实施者自行决定的.

典型的C程序在内存中平放,有机会通过更改brk()值来增加.通常,HEAP刚好低于此brk值,并且增加的brk增加了可用堆的数量.

单个STACK通常是HEAP下面的一个区域,它是一个内存区域,直到下一个固定内存块的顶部才包含任何有价值的内容.下一个块通常是CODE,它可以在其时代的一个着名黑客中被堆栈数据覆盖.

一个典型的存储器块是BSS(一个零值块),它在一个制造商的产品中偶然没有归零.另一个是包含初始化值的DATA,包括字符串和数字.第三个是包含CRT(C运行时),main,函数和库的CODE.

UNIX中虚拟内存的出现改变了许多约束.没有客观理由说明为什么这些块需要连续,或固定大小,或现在以特定方式排序.当然,在UNIX之前没有遭受这些限制的Multics.这是一个显示那个时代的存储器布局之一的示意图.

虚拟内存中每个进程的堆栈,堆和数据:

几美分:我认为,绘制内存图形化更简单:

箭头 - 显示增长堆栈和堆的位置,进程堆栈大小有限制,在OS中定义,线程堆栈大小通常由线程创建API中的参数限制.堆通常限制为进程最大虚拟内存大小,例如32位2-4 GB.

这么简单的方法:进程堆通常用于进程和内部的所有线程,在常见情况下用于内存分配,例如malloc().

堆栈是快速存储器,用于存储常见情况函数返回指针和变量,作为函数调用中的参数处理,本地函数变量.

由于一些答案被挑剔,我将贡献我的螨虫.

令人惊讶的是,没有人提到多个(即与运行的OS级线程的数量无关)调用堆栈不仅可以在外来语言(PostScript)或平台(Intel Itanium)中找到,还可以在光纤,绿色线程中找到协同程序的一些实现.

纤维,绿线和协同程序在很多方面都很相似,这会导致很多混乱.光纤和绿色线程之间的区别在于前者使用协作式多任务处理,而后者可能具有协作式或抢占式(或甚至两者).有关纤维和协程之间的区别,请参见此处.

在任何情况下,光纤,绿色线程和协同程序的目的是在一个OS级别的线程中同时执行多个函数,但不能并行执行(参见这个区别的SO问题),相互之间来回传递控制以有组织的方式.

使用光纤,绿色线程或协程时,每个函数通常都有一个单独的堆栈.(从技术上讲,不仅仅是一个堆栈,而是整个执行上下文是每个函数.最重要的是,CPU寄存器.)对于每个线程,存在与并发运行函数一样多的堆栈,并且线程在执行每个函数之间切换根据你的程序的逻辑.当函数运行到其末尾时,其堆栈将被销毁.因此,堆栈的数量和生命周期是动态的,并不是由OS级线程的数量决定的!

请注意,我说" 每个函数通常有一个单独的堆栈".有俩都stackful和无堆叠 couroutines的实现.最值得注意的stackful C++实现是Boost.Coroutine和微软PPL的async/await.(但是,C++的可恢复函数(又名" async和await"),它们被提议用于C++ 17,可能会使用无堆栈协程.)

纤维对C++标准库的提议即将发布.此外,还有一些第三方库.绿色线程在Python和Ruby等语言中非常流行.

我有一些东西要分享,虽然已经涵盖了主要观点.

堆

• 非常快速的访问.
• 存储在RAM中.
• 这里加载函数调用以及传递的局部变量和函数参数.
• 当程序超出范围时,会自动释放空间.
• 存储在顺序存储器中.

堆

• 相对于Stack而言访问速度较慢.
• 存储在RAM中.
• 动态创建的变量存储在此处,以后需要在使用后释放分配的内存.
• 存储分配完成的任何位置都存储,始终由指针访问.

有趣的说明:

• 如果函数调用已存储在堆中,则会产生两个混乱点:
  1. 由于堆栈中的顺序存储,执行速度更快.堆中的存储会导致大量的时间消耗,从而使整个程序执行得更慢.
  2. 如果函数存储在堆中(指针指向凌乱的存储空间),则无法返回调用程序地址(由于内存中的顺序存储,该堆栈会返回).

哇！如此众多的答案，我认为其中没有一个答案正确...

1）它们在哪里和什么（物理上在真实计算机的内存中）？

堆栈是从分配给程序映像的最高内存地址开始的内存，然后从那里递减值。它保留给调用的函数参数以及函数中使用的所有临时变量。

有两个堆：公共堆和私有堆。

私有堆从程序中代码的最后一个字节之后的16字节边界（对于64位程序）或8字节边界（对于32位程序）开始，然后从那里开始增加值。也称为默认堆。

如果私有堆太大，则它将与堆栈区域重叠，如果私有堆太大，则堆栈将与堆栈重叠。由于堆栈从较高的地址开始，然后一直向下移动至较低的地址，因此通过适当的破解，您可以使堆栈变大，以至于溢出专用堆区域并重叠代码区域。然后，诀窍是要重叠足够的代码区域，以便可以将其连接到代码中。这样做有些棘手，您可能会遇到程序崩溃的风险，但它既简单又有效。

公共堆位于程序映像空间之外的自己的内存空间中。如果内存资源稀缺，则会将该内存虹吸到硬盘上。

2）它们在多大程度上受操作系统或语言运行时的控制？

堆栈由程序员控制，私有堆由OS管理，而公共堆则不受任何人控制，因为它是OS服务-您发出请求，然后授予或拒绝请求。

2b）他们的范围是什么？

它们对于该程序都是全局的，但是其内容可以是私有的，公共的或全局的。

2c）是什么决定了每个尺寸？

堆栈和专用堆的大小由编译器运行时选项确定。公共堆在运行时使用size参数初始化。

2d）是什么使速度更快？

它们并不是为了快速而设计的，而是被设计为有用的。程序员如何利用它们确定它们是“快速”还是“慢速”

参考：

https://norasandler.com/2019/02/18/Write-a-Compiler-10.html

https://docs.microsoft.com/zh-CN/windows/desktop/api/heapapi/nf-heapapi-getprocessheap

https://docs.microsoft.com/zh-CN/windows/desktop/api/heapapi/nf-heapapi-heapcreate

许多答案都是正确的概念,但我们必须注意硬件(即微处理器)需要一个堆栈来允许调用子程序(汇编语言中的CALL ......).(OOP人会称之为方法)

在堆栈上保存返回地址并调用→push/ret→pop直接在硬件中管理.

您可以使用堆栈传递参数..即使它比使用寄存器慢(微处理器大师会说或者是一本很好的20世纪80年代的BIOS书......)

• 没有堆栈,没有微处理器可以工 (我们无法想象一个程序,即使在汇编语言中,没有子程序/函数)
• 没有堆就可以.(汇编语言程序可以在没有,因为堆是OS概念的情况下,作为malloc,即OS/Lib调用.

堆栈使用速度更快:

• 硬件,甚至推/弹都非常有效.
• malloc需要进入内核模式,使用执行某些代码的锁/信号量(或其他同步原语)并管理跟踪分配所需的一些结构.