来自Wikianwser。

堆叠堆叠

当函数或方法调用一个函数或方法调用另一个函数,而该函数轮流调用另一个函数等时,所有这些函数的履行将一直暂停,直到最后一个函数返回其值。

此挂起函数调用链链是堆叠, 因为堆叠( 功能调用) 中的元素互相依赖 。

在处理例外情况和处决线索时,堆叠很重要。

堆肥

堆积仅仅是存储变量的程序所使用的内存。 堆积( 变数) 元素不互相依赖, 随时可以随机访问 。

简言之,他们的意思是命令而不是命令!

堆叠:在堆叠项目中, 东西在彼此的顶端, 这意味着要更快和更有效 才能被处理!

所以总是有一个索引来指向特定项目, 处理速度也会更快, 这些项目之间也有关系!

堆肥:没有订单,处理速度会放慢, 价值会混乱在一起,没有具体的订单或索引... 是有随机的,它们之间没有关系... 所以执行和使用时间可以不同...

i 还创建下面的图像, 以显示它们可能看起来如何 :

调

堆叠 :

堆叠上创建的变量将超出范围,自动交易。 与堆叠上的变量相比, 分配速度要快得多。 使用实际的堆叠数据结构执行。 存储本地数据、 返回地址、 参数通过时使用的方法。 当堆叠过多使用时, 可能会出现堆叠溢出( 大多来自无限或过深的循环, 非常大的配置) 。 堆叠上创建的数据可以在没有指针的情况下使用 。

堆积 :

在 c+++ 中, 堆积上的变量必须手动销毁, 并且绝不会掉出范围 。 数据通过删除、 删除或自由解脱而解脱。 与堆叠上的变量相比, 分配速度较慢。 需要时使用来分配块块数据供程序使用。 当有大量分配和交易位置时, 可能会发生碎裂 。 在 c+++ 或 c 中, 堆积上生成的数据将被指向指针, 并分别与新数据或中位相分配 。

例如:

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;

其他答案只是避免解释静态分配意味着什么。 所以我会解释三种主要分配形式,以及它们通常与下面的堆积、堆叠和数据段的关系。 我还会在 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

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

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

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

堆积物,

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

调

堆叠堆叠

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

调

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

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

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

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

科学家在最初决定两个建筑(Von Neumann,这里所有东西都被视为数据,Harvard,那里保留了用于指示的记忆区和另一个数据区)之间。 最终,我们采用了von Neumann设计,现在一切都被认为是“相同的”。 当我在学习组装时,这让我很难接受 https://www.cs.virginia.edu/~evans/cs216/guides/x8。

上面所有内容都在谈论数据。我的猜测是,既然教学是一个定义的事物, 带有特定的记忆足迹, 它会进入堆叠, 所以所有在集合中讨论的“ 那些” 登记册都在堆叠中。 当然, 然后以对象为方向的编程, 将指示和数据混合到一个动态的结构中, 所以现在指示也会被保存在堆肥上?