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

当调用函数时,当调用该函数的参数加上一些其他间接费用时,会将数据堆放到堆栈中。一些信息(例如返回何处)也存储在那里。当您在函数中声明变量时,该变量也会被分配到堆栈中。

分配堆栈非常简单, 因为您总是在分配的反向顺序中进行排列。 在输入函数时会添加堆叠材料, 当退出时相应的数据会被删除。 这意味着您往往会留在堆栈的狭小区域, 除非您调用许多函数来调用其他函数( 或者创建循环解决方案 ) 。

堆积堆是一个通用名称, 用于您将创建的数据放在哪里 。 如果您不知道您的程序将创建多少飞船, 您可能会使用新的( 或商场或等效的) 操作器来创建每艘飞船 。 此分配将会停留一段时间, 因此我们很可能释放的东西 以不同于我们创建的顺序 。

因此,堆积要复杂得多,因为最终会出现一些未使用的记忆区域,这些区域与块间断 — — 内存会变得支离破碎。 找到您需要的大小的自由记忆是一个困难的问题。 这就是为什么应该避免堆积( 尽管它仍然经常被使用 ) 。

执行堆叠和堆叠通常要到运行时间 / os. 通常游戏和其他功能对于性能至关重要的应用程序会创建自己的内存解决方案,从堆叠中抓取一大块内存,然后在内部将内存分离出来,以避免依赖 os 来进行内存。

只有当你的记忆用法与常规有很大不同时, 也就是在游戏中, 在一个巨大的操作中加载一个水平, 并且可以在另一个巨大的操作中将整个批量扔掉时, 这才是实际的。

内存中的物理位置比你想的要少, 这是因为一种叫做虚拟内存的技术, 它使得您的程序认为您可以进入某个地址, 物理数据在其他地方( 即使是在硬盘上!) 。 您获得的堆叠地址随着调用树越深, 顺序越大。 堆积的地址是无法预测的( 具体化) , 坦率地说并不重要 。

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

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

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

直接回答你的问题:

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

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

其范围是什么?

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

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

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

是什么让一个更快?

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

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

在以下 c 代码中

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

下面是内存的管理方式

调

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

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

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

更多信息,请访问 :

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

此处 :

在堆叠和堆放上创建对象

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

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

a couple of cents: 我认为, 绘制内存图形比较简单, 将会是件好事 :

调

箭头 - 显示生长堆叠和堆肥的位置, 进程堆叠大小有限制, 以 os 定义, 以线状线条参数为线状堆叠大小限制通常创建 api 。 通常以进程最大虚拟内存大小为限制, 例如32 位 2-4 gb 。

如此简单的方式:过程堆积对于过程和内部所有线条来说都是一般的, 用于记忆分配, 常见的情况是像 malloc () 。

堆栈是用于存储常见函数返回指针和变量的快速存储存储存储的快速内存, 被处理为函数调用中的参数, 本地函数变量 。

堆叠堆叠

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

堆肥

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