堆栈和堆是什么以及在哪里？

川长思鸟来 2024-03-31 15:56 51阅读 0赞

## 问题描述： ##

什么是栈和堆？

它们在计算机内存中的物理位置？

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

他们的范围是什么？

是什么决定了它们的大小？

是什么让一个更快？

## 解决方案1: ##

> huntsbot.com – 程序员副业首选，一站式外包任务、远程工作、创意产品分享订阅平台。

堆栈是为执行线程预留的内存空间。调用函数时，堆栈顶部会保留一个块用于局部变量和一些簿记数据。当该函数返回时，该块将变为未使用，并且可以在下次调用函数时使用。堆栈始终以 LIFO（后进先出）顺序保留；最近保留的块总是下一个要释放的块。这使得跟踪堆栈变得非常简单；从堆栈中释放一个块只不过是调整一个指针。

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

每个线程都有一个堆栈，而应用程序通常只有一个堆（尽管有多个堆用于不同类型的分配并不少见）。

直接回答您的问题：

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

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

他们的范围是什么？

堆栈附加到线程，因此当线程退出时，堆栈被回收。堆通常由运行时在应用程序启动时分配，并在应用程序（技术进程）退出时回收。

是什么决定了它们每个的大小？

堆栈的大小在创建线程时设置。堆的大小在应用程序启动时设置，但可以随着空间的需要而增长（分配器从操作系统请求更多内存）。

是什么让一个更快？

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

https://i.stack.imgur.com/i6k0Z.png

> huntsbot.com洞察每一个产品背后的需求与收益，从而捕获灵感

`好的答案 - 但我认为你应该补充一点，虽然堆栈是在进程启动时由操作系统分配的（假设存在操作系统），但它由程序内联维护。这也是堆栈更快的另一个原因 - 推送和弹出操作通常是一条机器指令，现代机器可以在一个周期内完成其中至少 3 条，而分配或释放堆涉及调用 OS 代码。`

`我真的被最后的图表弄糊涂了。我以为我明白了，直到我看到那张照片。`

`@Anarelle 处理器在有或没有操作系统的情况下运行指令。一个贴近我心的例子是 SNES，它没有 API 调用，没有我们今天所知的操作系统——但它有一个堆栈。在堆栈上分配是这些系统上的加法和减法，这对于通过从创建它们的函数返回而弹出时销毁的变量很好，但是将其与构造函数进行对比，其结果不能只是扔掉了。为此，我们需要堆，它与调用和返回无关。大多数操作系统都有一堆 API，没有理由自己做`

`“堆栈是留作暂存空间的内存”。凉爽的。但就 Java 内存结构而言，它实际上“搁置”在哪里？是堆内存/非堆内存/其他（Java 内存结构按照 betsol.com/2017/06/… ）`

`@JatinShashoo Java 运行时，作为字节码解释器，增加了一层虚拟化，所以你提到的只是 Java 应用程序的观点。从操作系统的角度来看，这只是一个堆，Java 运行时进程在其中分配一些空间作为已处理字节码的“非堆”内存。该操作系统级堆的其余部分用作存储对象数据的应用程序级堆。`

## 解决方案2: ##

> huntsbot.com高效搞钱，一站式跟进超10+任务平台外包需求

堆：

像堆一样存储在计算机 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;

`指针 pBuffer 和 b 的值位于堆栈上，并且很可能分配在函数的入口处。根据编译器的不同，缓冲区也可能在函数入口处分配。`

`一种常见的误解是，由 C99 语言标准（可在 open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf 获得）定义的 C 语言需要一个“堆栈”。事实上，“堆栈”这个词甚至没有出现在标准中。这回答 wrt/ 到 C 的堆栈使用的陈述通常是正确的，但语言绝不要求。请参阅 knosof.co.uk/cbook/cbook.html 了解更多信息，特别是如何在 en.wikipedia.org/wiki/Burroughs_large_systems 等奇数架构上实现 C`

`@Brian您应该解释为什么在堆栈上创建缓冲区[]和pBuffer指针以及为什么在堆上创建pBuffer的数据。我认为有些人可能会对您的回答感到困惑，因为他们可能认为程序专门指示在堆栈和堆上分配内存，但事实并非如此。是因为 Buffer 是值类型而 pBuffer 是引用类型吗？`

`“负责内存泄漏” - 堆不负责内存泄漏！懒惰/健忘/ex-java 编码员/不废话的编码员是！`

`此外，关于范围和分配的评论是错误的 - 范围根本没有连接到堆栈或堆。堆上的变量必须手动销毁，并且永远不会超出范围。不正确；更正确的说法是“当引用它们的变量超出范围时，不会释放堆上的数据。释放它们取决于您（或垃圾收集器）。`

## 解决方案3: ##

> huntsbot.com洞察每一个产品背后的需求与收益，从而捕获灵感

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

在一堆物品中，物品按照它们放置在那里的顺序一个放在另一个上面，您只能移除最上面的一个（不会将整个东西翻倒）。堆栈的简单性在于您不需要维护一个包含每个已分配内存部分的记录的表；您需要的唯一状态信息是指向堆栈末尾的单个指针。要分配和取消分配，您只需增加和减少单个指针。注意：有时可以实现堆栈以从一段内存的顶部开始并向下扩展而不是向上增长。

在堆中，物品的放置方式没有特定的顺序。您可以按任何顺序进入和移除项目，因为没有明确的“顶部”项目。堆分配需要维护已分配和未分配内存的完整记录，以及一些开销维护以减少碎片，找到足够大以适应请求大小的连续内存段，等等。内存可以随时释放，留下可用空间。有时，内存分配器将执行维护任务，例如通过移动分配的内存或垃圾收集来对内存进行碎片整理 - 在运行时识别内存不再在范围内并释放它。

这些图像应该很好地描述了在堆栈和堆中分配和释放内存的两种方式。嗯！

它们在多大程度上受操作系统或语言运行时的控制？如前所述，堆和堆栈是通用术语，可以通过多种方式实现。计算机程序通常有一个称为调用堆栈的堆栈，它存储与当前函数相关的信息，例如指向它被调用的任何函数的指针，以及任何局部变量。因为函数调用其他函数然后返回，所以堆栈会增长和缩小以保存来自调用堆栈更下方的函数的信息。程序实际上并没有对其进行运行时控制。它由编程语言、操作系统甚至系统架构决定。堆是用于任何动态随机分配的内存的通用术语；即乱序。内存通常由操作系统分配，应用程序调用 API 函数来执行此分配。管理动态分配的内存需要相当多的开销，这通常由所使用的编程语言或环境的运行时代码处理。

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

是什么决定了它们每个的大小？同样，它取决于语言、编译器、操作系统和架构。堆栈通常是预先分配的，因为根据定义它必须是连续的内存。语言编译器或操作系统决定了它的大小。您不会在堆栈上存储大量数据，因此它将足够大以至于永远不会完全使用它，除非在不需要的无限递归（因此，“堆栈溢出”）或其他不寻常的编程决策的情况下。堆是可以动态分配的任何东西的总称。根据你看待它的方式，它的大小会不断变化。在现代处理器和操作系统中，它的确切工作方式无论如何都是非常抽象的，所以你通常不需要太担心它是如何工作的，除了（在它允许你的语言中）你不能使用内存您尚未分配或已释放的内存。

是什么让一个更快？堆栈更快，因为所有空闲内存始终是连续的。不需要维护所有空闲内存段的列表，只需一个指向当前堆栈顶部的指针。为此，编译器通常将此指针存储在一个特殊的快速寄存器中。更重要的是，堆栈上的后续操作通常集中在非常接近的内存区域中，这在非常低的级别有利于处理器片上缓存的优化。

`大卫 我不同意这是一个好的形象，或者“下推堆栈”是一个很好的术语来说明这个概念。当您将某些内容添加到堆栈时，堆栈的其他内容不会被下推，它们保持在原处。`

`这个答案包含一个很大的错误。静态变量不在堆栈上分配。请参阅我的回答 [链接] stackoverflow.com/a/13326916/1763801 进行说明。您将“自动”变量等同于“静态”变量，但它们完全不同`

`具体来说，您说“静态分配的局部变量”是在堆栈上分配的。实际上它们是在数据段中分配的。只有自动分配的变量（包括大多数但不是所有的局部变量，以及通过值而不是通过引用传递的函数参数）在堆栈上分配。`

`我刚刚意识到你是对的 - 在 C 中，静态分配是它自己独立的东西，而不是任何非动态的术语。我已经编辑了我的答案，谢谢。`

`不仅仅是 C。Java、Pascal、Python 和许多其他人都有静态分配、自动分配和动态分配的概念。说“静态分配”在任何地方都意味着同样的事情。在任何语言中，静态分配都不意味着“非动态”。您想要为您所描述的内容（即堆栈上的内容）使用术语“自动”分配。`

## 解决方案4: ##

> huntsbot.com – 程序员副业首选，一站式外包任务、远程工作、创意产品分享订阅平台。

（我已将这个答案从另一个或多或少是这个问题的欺骗的问题中移出。）

您的问题的答案是特定于实现的，并且可能因编译器和处理器架构而异。但是，这里有一个简化的解释。

堆栈和堆都是从底层操作系统分配的内存区域（通常是按需映射到物理内存的虚拟内存）。

在多线程环境中，每个线程都有自己完全独立的堆栈，但它们将共享堆。并发访问必须在堆上进行控制，而在堆栈上是不可能的。

堆

堆包含已用块和空闲块的链表。通过从空闲块之一创建合适的块来满足堆上的新分配（通过 new 或 malloc）。这需要更新堆上的块列表。有关堆上块的元信息也存储在堆上，通常位于每个块前面的一小块区域中。

随着堆的增长，新块通常从低地址分配到高地址。因此，您可以将堆视为内存块的堆，随着内存的分配，其大小会增加。如果堆对于分配来说太小，通常可以通过从底层操作系统获取更多内存来增加大小。

分配和释放许多小块可能会使堆处于这样一种状态，即在已使用的块之间散布着许多小的空闲块。分配大块的请求可能会失败，因为没有一个空闲块大到足以满足分配请求，即使空闲块的组合大小可能足够大。这称为堆碎片。

当与空闲块相邻的已用块被释放时，新的空闲块可以与相邻的空闲块合并以创建更大的空闲块，从而有效地减少堆的碎片。

https://i.stack.imgur.com/0Obi0.png

堆栈

堆栈通常与 CPU 上名为堆栈指针的特殊寄存器密切配合工作。最初，堆栈指针指向堆栈的顶部（堆栈上的最高地址）。

CPU 有特殊的指令，用于将值压入堆栈并将它们从堆栈中弹出。每次推送都将值存储在堆栈指针的当前位置并减少堆栈指针。 pop 检索堆栈指针指向的值，然后增加堆栈指针（不要被以下事实混淆：向堆栈添加值会减少堆栈指针，而删除值会增加堆栈指针。记住堆栈增长到底部）。存储和检索的值是 CPU 寄存器的值。

如果函数有参数，则在调用该函数之前将这些参数压入堆栈。然后，函数中的代码能够从当前堆栈指针向上导航堆栈以定位这些值。

当调用函数时，CPU 使用特殊指令将当前指令指针压入堆栈，即堆栈上执行的代码的地址。 CPU 然后通过将指令指针设置为被调用函数的地址来跳转到该函数。稍后，当函数返回时，旧指令指针从堆栈中弹出，并在调用函数后的代码处继续执行。

进入函数时，堆栈指针会减小，以便在堆栈上为本地（自动）变量分配更多空间。如果函数有一个本地 32 位变量，则在堆栈上留出四个字节。当函数返回时，堆栈指针被移回以释放分配的区域。

嵌套函数调用就像一个魅力。每次新调用都会分配函数参数、局部变量的返回地址和空间，这些激活记录可以为嵌套调用堆叠，并在函数返回时以正确的方式展开。

由于堆栈是有限的内存块，调用太多嵌套函数和/或为局部变量分配太多空间可能会导致堆栈溢出。通常，用于堆栈的内存区域的设置方式是，在堆栈底部（最低地址）下方写入将触发 CPU 中的陷阱或异常。这种异常情况可以被运行时捕获并转换为某种堆栈溢出异常。

https://i.stack.imgur.com/9UshP.png

可以在堆而不是堆栈上分配函数吗？

不，函数（即本地或自动变量）的激活记录分配在堆栈上，该堆栈不仅用于存储这些变量，还用于跟踪嵌套函数调用。

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

但是，堆栈是与处理器架构密切相关的更底层的功能。当没有足够的空间时增加堆并不太难，因为它可以在处理堆的库调用中实现。然而，增加堆栈通常是不可能的，因为堆栈溢出只有在为时已晚时才被发现；关闭执行线程是唯一可行的选择。

`@Martin - 一个非常好的答案/解释，而不是更抽象的接受答案。一个显示堆栈指针/寄存器用于函数调用的示例汇编程序将更具说明性。`

`每个引用类型都是值类型（int、string 等）的组合。据说，值类型存储在堆栈中，而不是当它们是引用类型的一部分时它是如何工作的。`

`这个答案在我看来是最好的，因为它帮助我理解了 return 语句的真正含义以及它与我不时遇到的这个“返回地址”的关系，将函数压入堆栈意味着什么，以及为什么将函数压入堆栈。很好的答案！`

`我认为这是最好的，即提到堆/堆栈是非常特定于实现的。其他答案假设了很多关于语言和环境/操作系统的事情。 +1`

`你是什么意思“然后函数中的代码能够从当前堆栈指针向上导航堆栈以找到这些值。” ?你能详细说明一下吗？`

## 解决方案5: ##

> 打造属于自己的副业，开启自由职业之旅，从huntsbot.com开始!

在以下 C\# 代码中

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

这是内存的管理方式

https://i.stack.imgur.com/NS0k7.jpg

Local Variables 只需要在函数调用进入堆栈时持续。堆用于存放我们事先并不真正知道其生命周期但我们希望它们能持续一段时间的变量。在大多数语言中，如果我们想将变量存储在堆栈中，我们必须在编译时知道变量有多大。

对象（随着我们更新它们的大小会有所不同）在堆上，因为我们在创建时不知道它们会持续多久。在许多语言中，堆被垃圾收集以查找不再有任何引用的对象（例如 cls1 对象）。

在 Java 中，大多数对象直接进入堆。在 C / C++ 等语言中，当您不处理指针时，结构和类通常会保留在堆栈上。

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

The difference between stack and heap memory allocation « timmurphy.org

和这里：

Creating Objects on the Stack and Heap

本文为上图来源：Six important .NET concepts: Stack, heap, value types, reference types, boxing, and unboxing - CodeProject

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

`这是不正确的。 i 和 cls 不是“静态”变量。它们被称为“本地”或“自动”变量。这是一个非常重要的区别。有关说明，请参阅 [链接] stackoverflow.com/a/13326916/1763801`

`我没有说它们是静态变量。我说 int 和 cls1 是静态项。它们的内存是静态分配的，因此它们进入堆栈。这与需要动态内存分配的对象形成对比，因此在堆上进行。`

`我引用“静态项目......继续堆栈”。这完全是错误的。静态项进入数据段，自动项进入堆栈。`

`写那篇代码项目文章的人也不知道他在说什么。例如，他说“原始人需要静态类型内存”这完全不正确。没有什么能阻止您在堆中动态分配基元，只需编写类似“int array[] = new int[num]”之类的东西，瞧，在 .NET 中动态分配的基元。这只是几个不准确之处之一。`

`@SnowCrash 关于您的图片的一个问题 - 分配 y 后如何访问 i？我必须弹出y吗？交换它们？如果有很多局部变量将它们分开怎么办？`

## 解决方案6: ##

> huntsbot.com提供全网独家一站式外包任务、远程工作、创意产品分享与订阅服务!

堆栈当您调用一个函数时，该函数的参数加上一些其他开销都放在堆栈上。一些信息（例如去哪里返回）也存储在那里。当您在函数中声明一个变量时，该变量也会在堆栈上分配。

释放堆栈非常简单，因为您总是以与分配相反的顺序释放。当您输入函数时会添加堆栈内容，退出函数时会删除相应的数据。这意味着您倾向于停留在堆栈的一个小区域内，除非您调用许多调用许多其他函数的函数（或创建递归解决方案）。

堆堆是放置动态创建的数据的通用名称。如果您不知道您的程序将创建多少艘飞船，您可能会使用 new（或 malloc 或等效的）运算符来创建每艘飞船。这种分配会持续一段时间，所以我们很可能会以不同于我们创建它们的顺序释放它们。

因此，堆要复杂得多，因为最终会出现未使用的内存区域与块交错 - 内存变得碎片化。找到所需大小的空闲内存是一个难题。这就是为什么应该避免使用堆的原因（尽管它仍然经常使用）。

堆栈和堆的实现通常取决于运行时/操作系统。通常，对性能至关重要的游戏和其他应用程序会创建自己的内存解决方案，这些解决方案会从堆中获取大量内存，然后在内部将其分发出去，以避免依赖操作系统来获取内存。

这仅在您的内存使用与标准完全不同的情况下才实用 - 即对于您在一个巨大的操作中加载一个关卡并且可以在另一个巨大的操作中丢弃全部内容的游戏。

内存中的物理位置 这并不像您想象的那么相关，因为一种称为 Virtual Memory 的技术使您的程序认为您可以访问物理数据位于其他位置的某个地址（即使在硬盘！）。随着调用树的深入，您获得的堆栈地址将按递增顺序排列。堆的地址是不可预测的（即特定于实现的）并且坦率地说并不重要。

`避免使用堆的建议非常强烈。现代系统具有良好的堆管理器，并且现代动态语言广泛使用堆（程序员无需真正担心它）。我会说使用堆，但是使用手动分配器，不要忘记释放！`

`如果您可以使用堆栈或堆，请使用堆栈。如果不能使用堆栈，真的别无选择。我经常使用这两种方法，当然使用 std::vector 或类似的东西会命中堆。对于新手来说，你可以避免堆，因为堆栈就是这么简单！！`

`如果您的语言没有实现垃圾收集，智能指针（围绕指针的单独分配的对象，对动态分配的内存块进行引用计数）与垃圾收集密切相关，并且是一种在安全中管理堆的好方法并且无泄漏的方式。它们在各种框架中实现，但对于您自己的程序也并不难实现。`

`“这就是为什么应该避免使用堆的原因（尽管它仍然经常使用）。”我不确定这实际上意味着什么，尤其是在许多高级语言中以不同方式管理内存时。由于这个问题被标记为与语言无关，我想说这个特定的评论/行不合适且不适用。`

`好点@JonnoHampson - 虽然你提出了一个有效的观点，但我认为如果你使用 GC 使用“高级语言”，你可能根本不关心内存分配机制 - 所以不要甚至关心堆栈和堆是什么。`

## 解决方案7: ##

> huntsbot.com提供全网独家一站式外包任务、远程工作、创意产品分享与订阅服务!

其他答案只是避免解释静态分配的含义。因此，我将在下面解释三种主要的分配形式以及它们通常与堆、堆栈和数据段的关系。我还将展示一些 C/C++ 和 Python 中的示例，以帮助人们理解。

“静态”（AKA 静态分配）变量不在堆栈上分配。不要这么假设——很多人这样做只是因为“静态”听起来很像“堆栈”。它们实际上既不存在于堆栈中，也不存在于堆中。它们是所谓的 data segment 的一部分。

但是，通常最好考虑“范围”和“生命周期”而不是“堆栈”和“堆”。

范围是指代码的哪些部分可以访问变量。通常我们会考虑局部作用域（只能由当前函数访问）与全局作用域（可以在任何地方访问），尽管作用域会变得更加复杂。

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

尽管大多数编译器和解释器在使用堆栈、堆等方面类似地实现此行为，但只要行为正确，编译器有时可能会破坏这些约定。例如，由于优化，局部变量可能只存在于寄存器中或被完全删除，即使大多数局部变量存在于堆栈中。正如一些评论中所指出的，您可以自由地实现一个编译器，它甚至不使用堆栈或堆，而是使用其他一些存储机制（很少这样做，因为堆栈和堆非常适合此）。

我将提供一些简单的带注释的 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 具有静态分配。这不直观！出于这个原因，我在描述范围时尽量不要使用“静态”这个词，而是说“文件”或“文件受限”范围之类的东西。然而，许多人使用短语“静态”或“静态范围”来描述只能从一个代码文件访问的变量。在生命周期的上下文中，“静态”始终意味着变量在程序启动时分配并在程序退出时释放。

有些人认为这些概念是特定于 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

`我将在函数中声明的静态变量称为仅具有本地可访问性，但通常不会使用术语“作用域”。此外，可能值得注意的是，语言的一个堆栈/堆方面基本上具有零灵活性：将执行上下文保存在堆栈上的语言不能使用相同的堆栈来保存需要比创建它们的上下文更长的东西.像 PostScript 这样的一些语言有多个堆栈，但有一个更像堆栈的“堆”。`

`@supercat 这一切都说得通。我将范围定义为“代码的哪些部分可以访问变量”（并且觉得这是最标准的定义）所以我认为我们同意:)`

`你一定在开玩笑。你真的可以在函数中定义静态变量吗？`

`@zaeemsatar 绝对，这在 C 代码中并不常见`

`@ZaeemSattar 将静态函数变量想象为隐藏的全局变量或私有静态成员变量。`

## 解决方案8: ##

> huntsbot.com提供全网独家一站式外包任务、远程工作、创意产品分享与订阅服务!

其他人已经很好地回答了粗略的笔画，所以我将提供一些细节。

堆栈和堆不必是单数。拥有多个堆栈的常见情况是进程中有多个线程。在这种情况下，每个线程都有自己的堆栈。您还可以拥有多个堆，例如，某些 DLL 配置可能会导致从不同堆分配不同的 DLL，这就是为什么释放由不同库分配的内存通常不是一个好主意的原因。在 C 中，您可以通过使用在堆栈上分配的 alloca 来获得可变长度分配的好处，而不是在堆上分配的 alloc。此内存不会在您的 return 语句中保留下来，但它对于暂存缓冲区很有用。在 Windows 上创建一个您不经常使用的巨大临时缓冲区并不是免费的。这是因为编译器会生成一个堆栈探测循环，每次输入函数时都会调用该循环以确保堆栈存在（因为 Windows 在堆栈末尾使用单个保护页来检测何时需要增加堆栈。如果您访问的内存超过堆栈末尾的一页，您将崩溃）。例子：

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

`Re“与alloc相对”：您的意思是“与malloc相对”吗？`

`@PeterMortensen 这不是 POSIX，不能保证可移植性。`

## 解决方案9: ##

> huntsbot.com汇聚了国内外优秀的初创产品创意，可按收入、分类等筛选，希望这些产品与实践经验能给您带来灵感。

其他人已经直接回答了您的问题，但是在尝试理解堆栈和堆时，我认为考虑传统 UNIX 进程的内存布局（没有线程和基于 mmap() 的分配器）是有帮助的。 Memory Management Glossary 网页包含此内存布局的图表。

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

在没有虚拟内存的系统中，例如一些嵌入式系统，通常采用相同的基本布局，只是堆栈和堆的大小是固定的。但是，在其他嵌入式系统中（例如基于 Microchip PIC 单片机的系统），程序堆栈是一个单独的内存块，无法通过数据移动指令寻址，只能通过程序流指令（调用、返回等）。其他体系结构（例如 Intel Itanium 处理器）具有 multiple stacks。从这个意义上说，堆栈是 CPU 架构的一个元素。

## 解决方案10: ##

> huntsbot.com – 高效赚钱，自由工作

什么是堆栈？

堆栈是一堆对象，通常是整齐排列的对象。

https://i.stack.imgur.com/GTa97.jpg

计算架构中的堆栈是以后进先出的方式添加或删除数据的内存区域。在多线程应用程序中，每个线程都有自己的堆栈。

什么是堆？

堆是杂乱无章的东西堆积起来的不规则集合。

https://i.stack.imgur.com/rz43z.jpg

在计算架构中，堆是动态分配的内存区域，由操作系统或内存管理器库自动管理。在程序执行期间，堆上的内存会被定期分配、释放和调整大小，这可能会导致称为碎片的问题。当分配的内存对象之间的小空间太小而无法容纳额外的内存对象时，就会发生碎片。最终结果是不能用于进一步内存分配的堆空间百分比。

两者一起

在多线程应用程序中，每个线程都有自己的堆栈。但是，所有不同的线程将共享堆。因为在多线程应用程序中不同的线程共享堆，这也意味着线程之间必须进行一些协调，以便它们不会尝试访问和操作堆中的相同内存块同时。

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

堆栈比堆快得多。这是因为在堆栈上分配内存的方式。在堆栈上分配内存就像向上移动堆栈指针一样简单。

对于刚接触编程的人来说，使用堆栈可能是一个好主意，因为它更容易。因为堆栈很小，所以当您确切知道数据需要多少内存时，或者如果您知道数据的大小非常小，您会想要使用它。当您知道需要大量内存来存储数据时，最好使用堆，或者您只是不确定需要多少内存（例如使用动态数组）。

Java 内存模型

https://i.stack.imgur.com/yZK6t.png

堆栈是存储局部变量（包括方法参数）的内存区域。当涉及到对象变量时，这些仅仅是堆上实际对象的引用（指针）。每次实例化一个对象时，都会留出一块堆内存来保存该对象的数据（状态）。由于对象可以包含其他对象，因此其中一些数据实际上可以保存对这些嵌套对象的引用。

## 解决方案11: ##

> huntsbot.com全球7大洲远程工作机会，探索不一样的工作方式

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

堆是由操作系统提供给应用程序的内存的一部分，通常通过诸如 malloc 之类的系统调用。在现代操作系统上，这个内存是一组只有调用进程才能访问的页面。

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

因为您在启动程序之前已经分配了堆栈，所以在使用堆栈之前您永远不需要 malloc，所以这是一个轻微的优势。在实践中，很难预测在具有虚拟内存子系统的现代操作系统中什么会快什么会慢，因为页面是如何实现的以及它们存储在哪里是一个实现细节。

`在这里还值得一提的是，英特尔对堆栈访问进行了大量优化，尤其是诸如预测从函数返回的位置之类的事情。`

`原文链接：https://www.huntsbot.com/qa/g12k/what-and-where-are-the-stack-and-heap?lang=zh_CN`

> HuntsBot周刊–不定时分享成功产品案例，学习他们如何成功建立自己的副业–huntsbot.com