短短

a 堆叠用于静态内存分配和动态内存分配,两者都储存在计算机的顶部。

---

详细详细

堆叠堆叠

堆栈是一个“ lifo”( 最后一个, 第一个出来) 数据结构, 由 cupu 非常密切地管理和优化。 每次函数在显示新的变量时, 它会“ 挂在” 堆栈上。 然后, 每次函数退出, 所有被该函数推到堆栈的变量都被解开( 也就是说, 它们被删除 ) 。 一旦打开堆叠变量, 内存区域就会为其他堆叠变量提供 。

使用堆叠存储变量的优点是, 内存被管理 。 您不需要用手来分配内存, 也无需在不再需要时释放内存 。 更何况, 因为 CDP 组织堆叠内存的效率如此高, 读取和写入到堆叠变量的速度非常快 。

在此可以找到更多 。

---

堆积物,

计算机的内存区域不自动管理, 也不由 cpu 进行严格管理。 它是一个更自由的内存区域( 且更大) 。 要在堆中分配内存, 您必须使用 bloc () 或 calloc () , 它们是内嵌的 c 函数 。 一旦您在堆中分配内存, 您就有责任使用 free () 来在不再需要内存时处理内存 。

如果您不这样做, 您的程序将会有所谓的内存泄漏。 也就是说, 堆积上的内存仍将被搁置( 并且无法用于其它进程 ) 。 正如我们在调试部分看到的那样, 有一个名为 valgrind 的工具可以帮助您检测内存泄漏 。

与堆叠不同, 堆积的大小没有变量大小限制( 除了您的计算机的明显物理限制之外 ) 。 堆积的内存读和书写要慢一点, 因为需要用指针来访问堆积的内存 。 我们很快会讨论指针问题 。

与堆叠不同的是,在堆积上创建的变量可以被任意函数进入,在您的程序中的任何地方。堆积变量在范围上基本上是全球性的。

在此可以找到更多 。

---

堆栈上分配的变量直接存储到内存中, 访问此内存的时间非常快, 当程序编译时会处理其分配。 当函数或方法调用另一个函数, 转而调用另一个函数等时, 所有这些函数的履行将一直暂停, 直到最后一个函数返回其值。 堆栈总是保留在 lifo 顺序中, 最近保留的块总是下一个要解开的块 。

堆积上分配的变量的内存在运行时间分配,而访问此内存的时间稍慢一些,但堆积大小仅受虚拟内存大小的限制。 堆积中的元素不互相依赖, 随时可以随机访问。 您可以随时分配块块, 并随时释放它。 这使得跟踪堆积中哪些部分在任何特定时间分配或自由, 变得更加复杂 。

调

如果您确切知道在编译时间之前需要分配多少数据,您可以使用堆叠,而它并不太大。如果您不知道运行时需要多少数据,或者如果您需要分配大量数据,您可以使用堆叠。

在多轨情况下, 每串线索将拥有自己的完全独立的堆叠, 但是它们会共享堆叠 。 堆叠是特定的线条, 堆叠是特定的应用程序 。 堆叠很重要, 在例外处理和丝线处决中需要考虑 。

每一串线索都有堆叠, 而通常应用程序只有一堆(尽管对于不同种类的分配来说, 多堆堆并不罕见) 。

调

运行时, 如果应用程序需要更多堆肥, 它可以从空闲的内存中分配内存, 如果堆叠需要内存, 它可以从空闲的内存中分配内存, 用于应用程序的内存中分配内存 。

即使如此,这里和这里还有更详细的内容。

---

现在来回答你的问题吧

在多大程度上它们受国家或语言运行时间控制?

当线索创建时, os 分配每个系统级线索的堆叠。 通常, os 被语言运行时间调用来分配应用程序的堆叠 。

在此可以找到更多 。

其范围是什么?

已经在上方给定 。

“如果你确切知道在编译时间之前你需要分配多少数据,你可以使用堆叠。它并不太大。如果你不知道运行时你需要多少数据,或者你需要分配很多数据,你可以使用堆叠。”

在此可以找到更多 。

是什么决定了每个孩子的大小?

当创建线索时,堆栈的大小由 OS 设定。 程序启动时会设置堆积的大小, 但随着需要空间, 堆堆的大小会扩大( 分配器要求操作系统有更多的内存 ) 。

是什么让一个更快?

堆叠分配速度要快得多, 因为实际上它所做的就是移动堆叠指针。 使用内存池, 您可以从堆积分配中获取相似的性能, 但是这伴随着稍微增加的复杂性和它本身的头痛。

此外,堆叠对堆肥不仅是对性能的考量;它也告诉你很多关于物体的预期寿命。

在此可以找到细节 。

堆叠 :

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

堆积 :

在 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;

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

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

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

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

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

调

cpu 堆和堆积与堆积与堆积与堆积与堆积与堆积之间,

所有现代的 cpus 都与“ 相同” 微处理理论合作: 它们都基于所谓的“ 注册者” 和一些“ 堆叠” 来取得性能。 所有 cpus 从一开始就有堆叠登记簿, 他们总是在这里, 说话的方式,如我所知。 组装语言从一开始就是相同的, 尽管从一开始, 直到... 微软和中间语言( i) 都改变了范式, 有了一种 oo 虚拟机组装语言。 这样我们就可以有一些 cli/ cil 。

cpus有堆叠登记册来加快存取记忆的速度,但与其他登记册相比,这些登记册是有限的,以充分利用所有可用于处理过程的存储器。 这就是为什么我们谈论堆叠和堆积分配的原因。

简而言之,一般而言,堆积是慢慢的,用于“全球”实例和对象内容,因为堆叠小而快,用于“本地”变量和参考(隐藏的指针要忘记管理这些变量和参考)。

所以当我们在一个方法中使用新关键字时, 引用( int) 是在堆叠中创建的, 但是对象及其全部内容( 价值类型以及对象) 都在堆积中创建, 如果我记得的话。 但是本地基本值类型和阵列是在堆叠中创建的 。

内存存存取的差别在于单元格的参考级别:处理堆积,即整个过程的记忆,在处理 cpu 登记册方面要求比处理当地“更多” 的堆叠更为复杂,因为如果我记得, cpu 堆积登记册被用作基地址。

这就是为什么当我们有非常长或无限的循环电话或循环时, 我们很快地被堆积物溢出, 而不冻结现代电脑上的系统...

cheap(ing) 与. net 中的堆叠(ing) 。

堆堆堆和堆堆:知道差别

储存的静态类内存分配c

堆叠和堆放在哪里?

https://en.wikipedia.org/wiki/Memory_management

https://en.wikipedia.org/wiki/Stack_register

功率语言资源:

组组编程辅导

64和ia-32建筑软件开发手册

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

20世纪80年代,Unix像兔子一样传播,大公司自己滚动。 Exxon拥有一个,历史也失去了数十个品牌。 许多执行者都决定如何留下记忆。

典型的 c 程序在记忆中平坦,有机会通过改变 brk () 值来增加。 典型的情况是, 堆积量略低于这个 brk 值, 增加 brk 增加了可用堆积量 。

单堆叠一般是堆积层下的一个区域, 它是一个内存的块块, 在下一个固定的内存区块的顶部之前, 没有任何价值。 下一个块块通常是代码, 在其时代著名的黑客之一的堆叠数据中, 可能被堆叠数据覆盖 。

一个典型的内存区块是 bss (一个零值块) , 在一个制造商的报价中, 意外没有零。 另一个是包含初始值的数据, 包括字符串和数字。 第三个是包含 Crt( cruntime) 、 主机、 函数和图书馆的代码 。

虚拟内存在 unix 中出现 。 许多限制 。 这些区块需要毗连, 或固定大小, 或现在订购特定方式, 没有客观的理由 。 当然, unix 之前的多立方体没有受到这些限制的影响 。 下面是一张图表, 显示这个时代的记忆布局 。

调