(我将这一答案从另一个或多或少是本问题的代名词的问题移出。 )

您问题的答案是具体执行问题,可能因汇编者和处理结构而异。然而,这里是简单的解释。

堆叠和堆积都是从基本操作系统分配的内存区域(通常是虚拟内存,根据需要绘制成物理内存)。 在多轨环境中,每条线将有自己的完全独立的堆叠,但他们将共享堆叠。同时存取必须控制在堆积上,不可能在堆叠上。

堆积物,

堆积中含有一个用过的和自由的区块的链接列表。 堆积( 由新的或中转的) 上的新分配通过从一个自由区块中创建一个合适的区块来满足。 这需要更新堆积中的区块清单。 堆积中的区块的元信息也通常储存在堆积中, 保存在每个区块前面的小区域中。 当堆积中的新区块往往从下面的地址分配到更高的地址。 因此, 您可以将堆积视为一个堆积 o 。

调

堆叠堆叠

堆叠通常与名为堆叠指针的 cupu 上的特殊登记簿密切配合。 最初, 堆叠指针指向堆叠的顶部( 堆叠上的最高地址 ) 。 堆叠有将值推到堆叠上并将其从堆叠中弹出的特殊指令。 每一次推移都存储在堆叠指针当前位置的值, 并减少堆叠指针。 流行会检索堆叠指针指向的值, 然后增加堆叠指针( 不要) 。

调

能否在堆叠上而不是堆叠上分配函数 ?

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

如何管理堆肥真的取决于运行时间环境。 c 使用中转器, c++ 使用新的, 但很多其他语言都有垃圾收集 。

然而,堆叠是一个更低层次的特征,它与处理器结构紧密相连。 当没有足够的空间时, 堆叠会生长成堆不会太难, 因为可以在处理堆叠的图书馆电话中执行。 然而, 堆叠的堆叠往往不可能增长, 因为堆叠溢出的时间太晚才被发现; 关闭行刑线是唯一可行的选择。

许多答案作为概念是正确的,但我们必须指出,硬件(即微处理器)需要堆叠,才能调用子例程(用组装语言调用)。 (oop guys will call it ways)

在您保存返回地址的堆栈上, 并拨“ 推 / 重 ” Pop 由硬件直接管理 。

您可以使用堆叠来设定通过参数。 即使比使用登记册要慢( 微处理器大师会说, 或者好的 1980 年代生物书...) )

没有堆叠, 没有微处理器是行不通的。 (我们无法想象一个程序, 即使是在组装语言中, 没有子例程/功能) 没有它能工作的堆肥( 组装语言程序可以工作, 因为堆肥是一个 os 概念, 作为 malloc, 是一个 os/lib调用 ) 。

堆栈使用速度更快, 以 :

硬体是硬件,甚至推/棒也非常有效。 中转器需要输入内核模式,使用锁/石墨(或其他同步原始元素)执行某些代码,并管理一些跟踪分配情况所需的结构。

堆叠基本上是一个容易获取的内存,它只是将项目管理成一个 - 井 - 堆叠。只有事先知道其大小的物品才能进入堆叠。数字、字符串、布林恩就是这种情况。堆叠是无法预设准确大小和结构的物品的内存。由于天体和阵列可以在运行时变形和改变,它们必须进入堆叠。

源源代码:academinide

堆栈是内存的一部分,可以通过若干关键组装语言指令来操作,例如“pop”(从堆叠中移动并返回一个值)和“push”(将一个值推到堆叠中),但也可以调用(调用子例程 - 将地址推到堆叠中)和返回( 从子例程返回 - 将堆叠的地址从堆叠中跳出并跳到堆叠中)。这是堆叠指针登记册下方的内存区域,可以根据需要设置。堆叠也用于 pa 。

堆积是操作系统向一个应用程序提供的内存的一部分, 通常通过像马洛克这样的音响。 在现代套管上, 这个内存是一组只有呼叫程序才能进入的页面 。

堆叠的大小在运行时确定, 一般在程序启动后不会增长。 在 c 程序中, 堆叠需要足够大, 以保持每个函数中所有声明的变量。 堆叠会按需要动态增长, 但 巨头最终会发出呼唤( 它会增加的堆积量通常超过 merloc 要求的值, 这样至少有些未来的中枢不需要返回内核来获取更多的内核内存 。 此行为通常可以自定义 )

因为您在启动程序前已经分配了堆叠, 所以在您使用堆叠之前, 您从不需要在使用堆叠前使用滚动, 所以在实际操作中这是一个小的优势。 实际上, 很难预测什么是快速的,什么是缓慢的, 在拥有虚拟内存子系统的现代操作系统中, 因为这些页面是如何被安装的, 在哪里存储的, 是一个执行细节 。

在以下 c 代码中

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

下面是内存的管理方式

调

本地变量只要在堆栈中进行函数调用, 只需持续时间。 堆积层的堆积层用于那些我们并不真正了解其一生的变量, 但是我们期望这些变量会持续一段时间。 在大多数语言中, 关键是我们在编译时知道一个变量有多大, 如果我们想将其存储在堆叠中的话 。

对象(在更新时大小不同) 继续堆积, 因为我们不知道在创建时它们会持续多久。 在许多语言中, 堆积是垃圾, 以寻找不再有任何引用的对象( 如 cls1 对象) 。

在 java 中, 大多数对象会直接进入堆积。 以 c / c++、 structs 和 class 等语言, 当您不与指针打交道时, 通常会留在堆叠中 。

更多信息,请访问 :

堆叠和堆积内存分配的差别 Timmurphy.org

此处 :

在堆叠和堆放上创建对象

本条是上述图象的来源:六种重要的.net概念:堆叠、堆肥、价值类型、参考类型、拳击和开箱-代码项目

但要知道它可能含有一些不准确之处。

其他答案只是避免解释静态分配意味着什么。 所以我会解释三种主要分配形式,以及它们通常与下面的堆积、堆叠和数据段的关系。 我还会在 c/c++ 和 python 中展示一些例子,以帮助人们理解。

静态( 静态分配) 变量没有在堆叠上分配。 不要假设- 许多人只是因为“ 静态” 听起来像“ 堆叠 ” 。 它们实际上既不存在于堆叠中, 也不存在于堆叠中。 它们属于所谓的数据段 。

然而,一般而言,最好考虑“范围”和“终生”,而不是“堆积”和“堆积”。

范围指代码中哪些部分可以访问变量。 我们一般认为本地范围(只能通过当前函数访问)与全球范围(任何地方都可以访问)不同,尽管范围可能变得更加复杂。

当一个变量在程序执行期间被分配和交易时, 其使用寿命值是指变量在程序执行期间被分配和交易。 我们通常会想到静态分配( 在整个程序期间会持续不变, 使得它可用于在多个函数调用中存储相同的信息), 而会想到自动分配( 仅在对函数的单次调用中持续不变, 使得它可用于存储仅在您函数期间使用、 一旦完成即可丢弃的信息) 相对于动态

尽管大多数编译者和口译员在使用堆叠、堆堆堆等方面也采取了类似的做法,但只要行为正确,编译者有时会打破这些公约。例如,由于优化,本地变量可能只存在于登记册中,或者完全删除,即使大多数本地变量存在于堆叠中。正如在几个评论中所指出的,你可以自由实施一个甚至不使用堆叠或堆叠的编译者,但有些则可以使用

i 将提供一些简单的附加说明的 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.

一个特别令人印象深刻的例子说明为什么区分寿命和范围很重要,那就是变量可以具有局部范围,但固定寿命——例如,在上文的代码样本中“某些局部可变性”。这些变量可以使我们共同但非正式的命名习惯非常混乱。例如,我们说“本地”通常是指“局部范围自动分配变量”,而我们说“全球范围”通常是指“全球范围静态分配变量”。 不幸的是,当我们说“本地”时,我们通常是指“全球范围的静态分配变量”。

C/c+++中的一些语法选择加剧了这一问题,例如许多人认为全球变数不是“静态”的,

int var1; // Has global scope and static allocation
static int var2; // Has file scope and static allocation

int main() {return 0;}

请注意, 在以上声明中加上关键词“ 静态” 会使 var2 无法具有全球范围。 然而, 全球 val1 具有静态分布 。 这不是直观的 。 因此, 我试图在描述范围时永远不要使用“静态” 一词, 而不是说“ 文件” 或“ 文件有限” 的范围。 但是许多人使用“静态” 或“ 静态范围” 来描述一个变量, 只能从一个代码文件中访问 。 在生命周期中, “ 静态” 总是意指从一个代码文件中访问的变量 。

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