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

我觉得大部分的答案都是非常复杂和技术性的, 而我没有找到一个可以简单地解释这两个概念背后的理由的答案(即为什么人们首先创造这些概念? )和为什么你应该关心。

堆叠上的数据为临时和自动清理数据

堆积上的数据在手动删除前是永久的

就是这样。

更确切地说,

堆叠是用来作为 短暂或工作记忆的, 一个我们知道的记忆空间 将经常被完全删除, 不论在我们的节目的一生中, 我们在那里设置的乱七八糟。 这就像你桌上的备忘,

然而,这个堆积物是长期的记忆, 实际重要的文件, 我们将会储存, 咨询, 并依赖它创建后很长一段时间。 因此,它需要有一个完美的形式, 并严格包含重要数据。 为什么它要花费很多, 并且不能用于我们先例备忘录的用法。 将我的所有笔记带进一份学术性文件演示文稿, 写成书法, 是没有价值的, 甚至完全没有用处的。 然而,这个演示文稿是用书法写成书法的。

大多数最上面的答案只是实际计算机实际应用这一概念的技术细节。

因此,要从中取出什么是:

使我们的功能和物体的工作(一般而言)更相关 储存在堆叠上。

重要、永久和基础应用数据(一般而言)更切合需要储存在堆积上。

这就是为什么你需要管理和处理堆积物上的记忆分配, 但不必为堆积物费心。

当然, 需要从您的程序寿命的角度来看待这一点。 实际的人类重要数据显然需要存储在外部文件中 。 ( 由于是堆肥还是堆叠, 当您的程序终止时, 它们都会完全清除 。 )

ps:这些只是一般规则,你总是能找到边缘案例,每种语言都有其自己的执行和由此产生的怪异之处,这是作为概念和大拇指规则的指导。

堆叠 :

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

堆积 :

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

堆栈是作为执行线条的抓抓空间预留的内存。当函数被调用时,在堆栈顶部为本地变量和一些簿记数据预留一个区块。当该函数返回时,块就会被未使用,下次调用函数时就可以使用。堆栈总是保留在利弗(最先出)顺序中;最近保留的区块总是下一个要解开的区块。这样就可以很容易地跟踪堆叠; fr 。

堆积是用于动态分配的内存。 与堆叠不同, 堆积区块的分配和分配没有强制模式; 您可以随时分配块块, 并随时释放它。 这使得跟踪堆积中哪些部分在任何特定时间分配或免费更为复杂; 许多定制的堆积分配器可用于调和不同使用模式的堆积性能 。

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

直接回答你的问题:

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

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

其范围是什么?

堆栈附在线条上,因此当线条退出时,堆栈被回收。堆积通常在运行时在应用程序启动时分配,在应用程序(技术处理)退出时再回收。

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

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

是什么让一个更快?

堆叠速度更快, 因为访问模式使得从堆叠中分配和处理内存( 指针/ 内插器只是递增或衰减) 变得微不足道, 而堆叠在分配或交易位置上有复杂得多的簿记。 另外, 堆叠中的每个字节往往会非常频繁地被再利用, 这意味着它往往被映射到处理器的缓存处, 从而非常快。 堆积的另一个性能冲击是堆积, 主要是全球资源, 通常是 h 。

清晰的演示:图像来源: vikashazrati.wordpress.com

堆叠堆叠

记忆不会成为支离破碎的本地变量, 只能对堆叠大小(依赖的)变量进行限制, 无法调整大小

堆肥

可在全球范围内访问变量,没有内存大小的限制(相对而言)更慢的存取,没有保证有效使用空间的保障,随着分配内存区块,内存可能会随着时间而变得支离破碎,然后释放后,你必须管理内存(你负责分配和释放变量),变量可以使用地环调整大小()

哇! 这么多答案,我觉得其中之一 没有得到正确的答案...

(在真实的计算机记忆中)在哪里?

堆栈是作为分配给您的程序图像的最高内存地址开始的内存,然后从那里降低值。它保留给所谓的函数参数和函数中使用的所有临时变量。

有两层楼:公营和私营。

私人堆积始于程序代码的最后一字节之后的16字节边界( 64比特程序)或8比特边界( 32比特程序),然后从中增加值。它也被称为默认堆积。

如果私人堆肥过大, 它会重叠堆叠区域, 如果堆叠太大, 堆叠也会重叠堆叠区域。 因为堆叠从更高的地址开始, 并一直往下工作到较低的地址, 适当的黑客可以使堆叠变得如此大, 它会超过私人堆肥区域, 并重叠代码区域。 那么, 技巧就是将代码区域重叠到足够大的地方, 从而可以连接到代码中。 这样做有点棘手, 你可能会冒程序崩溃的风险, 但是它很容易, 而且非常容易。

公用堆积在它自己的记忆空间中, 它不在您的程序图像空间之内。 如果记忆资源变得稀缺, 这个记忆将会被吸到硬盘上 。

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

堆叠由程序员控制, 私人堆积由操作员管理, 公众堆积不为任何人控制, 因为它是一种操作员的服务-- 你提出请求, 要么被批准,要么被拒绝。

2(b) 其范围是什么?

它们都是全球性的,但内容可以是私人的,公共的,也可以是全球性的。

2(c) 由什么因素决定每个小组的大小?

您的编译器运行时间选项决定了堆叠和私有堆放的大小。公共堆放使用大小参数在运行时初始化。

2(d) 是什么使一个速度更快?

程序程序员如何使用它们来决定它们是“快”还是“慢”

ref:

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

https://learn.microsoft.com/en-us/windows/desktop/api/heapapi/nf-heapapi-getprocessheap

https://learn.microsoft.com/en-us/windows/desktop/api/heapapi/nf-heapapi-heapcreate