它们在哪里? 它们在哪里? (在真实的电脑记忆中)

回答: 两者都在记录和档案调控系统。

分会 :

内存就像一个书桌, HDDs/ SSDs( 永久存储) 像书架一样。 要阅读任何东西, 您必须在桌上打开一本书, 您只能在桌子上打开尽可能多的书。 要拿到一本书, 您必须把它从书架上拉出来, 然后在桌子上打开。 要退回一本书, 您必须关闭桌上的书架, 然后把它归还到书架上 。

堆积和堆积是我们给两种方式的汇编者提供的名称,它们将不同种类的数据储存在同一地点(即记录和档案管理)。

其范围是什么?
是什么决定了每个孩子的大小?
是什么让一个更快?

回答:

1. 堆叠为静态(固定大小)数据

   a 。编译者在编译时读取代码中使用的变量类型。

   (一) 为这些变量分配固定数量的内存。
   二. 此记忆的大小无法增长 。

   b. b. 数据内存是毗连的( 单个区块) , 所以访问是 有时有时 比堆积速度快

   c. 用于以下目的:放置在堆叠堆叠上的一个物体,该物体在超过堆叠大小的运行时会生成内存,导致 堆堆堆堆堆溢溢溢出错误

2. 堆肥用于动态(变化大小)数据

   a 。内存量仅受内存存储器可用空空空间数量的限制
   (一) 使用的数量在运行时可按需要增长或缩减。

   b. b. 数据由于项目在堆积上分配,只要在内存记录和档案记录室中存在空空空间,数据并不总是在毗连部分中,而 有时有时 访问比堆叠慢

   c. 用于以下目的:程序手动将项目与newkeyword 和 Must 手动移动此内存, 当它们使用它完成后 。
   一. 重复分配新内存的代码,在不再需要新内存时,不将新内存分配到内存泄漏。

分会 :

堆叠和堆积堆肥主要不是为了提高速度而引入;它们被引入是为了处理内存溢出。关于堆叠与堆积之间的第一个关注点应该是是否会出现内存溢出。如果一个对象打算将大小扩大为未知数量(如链接列表或其成员可以持有任意数量数据的对象),则将其放置在堆积上。尽可能使用 C++ 标准库(STL) 容器。矢量, 地图图图图地图, 和列表列表因为它们是记忆和速度效率高的,并增加使你的生活更加轻松(你不必担心记忆分配/迁移)。

在运行您的代码后, 如果您发现代码运行速度慢得令人无法接受, 然后返回并重新构思您的代码, 并查看它是否能够更有效地编程。 它可能会发现问题与堆叠或堆积完全无关( 比如使用迭代算法而不是循环算法, 看看 I/ O 对 CPU 的任务, 也许添加多读或多处理 ) 。

我说有时有时速度较慢/ 较快, 因为程序的速度可能与堆叠或堆叠上分配的项目无关 。

它们在多大程度上受到操作系统或语言运行时间的控制?

回答:

• 堆叠大小由汇编者在汇编时确定。

• 在运行期间,堆积大小各有不同。 (堆积在运行时与操作系统一起工作,以分配内存。)

分会 :

以下是更多关于控制和编译时间与运行时间操作的更多信息。

每台电脑都有独特的指令设置结构(ISA),即其硬件指令(例如“MOVE”、“JUMP”、“ADD”等)。

• 操作系统只不过是一个资源管理者(控制如何/何时/和何处使用内存、处理器、装置和信息)。

• 安全操作系统的ISA被称为光机其余命令被命名为扩展机。内核是扩展机器的第一层。 它控制着类似

  • 确定要使用处理器(调度器)的任务,
  • 分配给任务(调度员)的内存多少或硬件登记册多少,以及
  • 执行任务的顺序(交通控制器)。

• 当我们说“编译者”时,我们通常是指编译者、组装者和链接者在一起

  • 编译者将源代码转换为组装语言,并将其传给装配者,
  • 装配器将装配语言转换成机码(ISA命令),并传给链接器
  • 链接器将所有机器代码( 可能来自多个源文件) 合并成一个程序 。

• 机器代码在被执行时传递到内核, 由内核决定它何时应该运行并控制, 但机器代码本身包含ISA命令, 用于请求文件, 请求内存等。 所以代码发布 ISA 命令, 但一切都要通过内核 。

其他人直接回答了你的问题,但是,在试图理解堆叠和堆叠时,我认为,考虑传统的UNIX进程的记忆布局(没有线条和线条)是有益的。mmap()- 以基于分配器为基础。记忆管理词汇表网页上有一个内存布局图。

堆堆和堆堆堆传统上位于进程的虚拟地址空间的对面。当访问时,堆堆会自动增长,最多以内核设定的大小(可以与setrlimit(RLIMIT_STACK, ...)))当内存分配器援引brk()或sbrk()系统呼叫,绘制更多页的物理内存 进入该过程的虚拟地址空间。

在没有虚拟内存的系统中,例如一些嵌入系统,通常适用同样的基本布局,但堆叠和堆积大小固定。然而,在其他嵌入系统(例如基于微芯片的微控制器)中,程序堆叠是一个单独的内存块,无法通过数据移动指示处理,只能通过程序流指示(调用、返回等)进行间接修改或阅读。多个堆叠。从这个意义上说,堆叠是CPU结构的一个元素。

最重要的一点是,堆积和堆叠是记忆分配方法的通用术语,可以多种不同方式加以实施,这些术语适用于基本概念。

• 在一个堆叠的项目中,项目坐在另一堆的上方,按其放置的顺序排列,你只能删除顶端的项目(不折叠整件事情)。

  

  堆叠的简单性在于您不需要保存包含分配内存每一部分的记录的表格; 您所需要的唯一状态信息是到堆栈尾端的单指针。 要分配和取消分配, 您只需递增和缩减该单指针。 注意: 有时可以安装堆叠, 以开始于内存的顶部, 向下延伸, 而不是向上增长 。

• 在堆积中,项目放置方式没有特定顺序。您可以按任何顺序接触和删除项目,因为没有明确的“顶部”项目。

  

  高空分配需要完整记录什么是记忆分配,什么是记忆分配,什么不是,以及一些间接维护,以减少碎裂,发现毗连的内存部分大到足以满足要求的大小,等等。 内存可以在离开空闲空间的任何时候进行分配。 有时,内存分配器将执行维护任务,例如通过移动分配的内存或垃圾收集来消除内存的分散性,或者在运行时识别内存不再在范围之内的运行时间并进行分配。

这些图像应该能很好地描述 在堆叠和堆肥中分配和释放记忆的两种方式。

• 它们在多大程度上受到操作系统或语言运行时间的控制?

  如前所述,堆叠和堆叠是一般术语,可以多种方式实施。呼叫堆叠存储与当前函数相关的信息, 如指向它从哪个函数调用, 以及任何本地变量。 因为函数调用其他函数, 然后返回, 堆叠会增长并缩放, 以便从调用堆栈往下更远的函数中保留信息。 一个程序实际上没有运行时间控制; 它由编程语言、 OS 甚至系统架构决定 。

  堆积是一个通用术语,用于动态和随机分配的任何内存;即失序。内存通常由操作系统分配,应用程序中调用 API 函数来分配。管理动态分配内存需要相当一部分管理费,通常由所用编程语言或环境的运行时间代码处理。

• 其范围是什么?

  调用堆栈是一个低层次的概念, 以至于它与编程意义上的“ 范围” 无关。 如果您将一些代码拆解, 您将会看到与堆叠部分相对的指针样式引用, 但就更高层次的语言而言, 语言会强制实施它自己的范围规则 。 但是, 堆栈的一个重要方面是, 一旦一个函数返回, 任何本地的函数都会立即从堆叠中解开。 这与您所编程语言是如何工作的有关。 在堆放过程中, 它也很难定义。 范围是由操作系统所暴露的, 但是您的编程语言可能会增加它关于“ 范围” 在您的应用程序中是什么的规则 。 处理器结构和 OS 使用虚拟地址, 处理器可以翻译为物理地址, 并且有页面错误等 。 它们会跟踪哪些页面属于哪个应用程序。 但是, 您从不需要担心这一点, 因为您只是使用你编程语言用于分配和自由记忆的方法, 并检查错误( 如果由于任何原因分配/ 解析失败 ) 。

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

  同样,它取决于语言、编译器、操作系统和架构。 堆叠通常是预先分配的, 因为根据定义它必须是连续的内存。 语言编译器或操作系统决定其大小。 您不会在堆叠中存储大量数据, 因此它会足够大, 永远不能被充分利用, 除非在无谓的循环( 例如“ 堆叠溢出 ” ) 或其他不寻常的编程决定下。

  对于任何可以动态分配的东西来说, 堆积是一个通用的术语。 取决于您看它的方式, 它的大小在不断变化。 在现代的处理器和操作系统中, 它的运作方式是非常抽象的, 所以通常你不需要担心它是如何在内心深处运作的, 除了( 在它允许你使用的语言中) 您不能使用你还没有分配到的记忆或者你已经释放的记忆。

• 是什么让一个更快?

  堆叠速度更快, 因为所有自由内存总是毗连的 。 不需要保存自由内存所有部分的清单, 仅指堆叠当前顶部的单指针。 汇编者通常会将这个指针保存在特殊、 快速的文件中 。登记册登记簿更何况,堆叠上的后续操作通常集中在非常靠近的内存区内,这些内存区在非常低的水平上,对处理器置存的缓存器优化是有好处的。

堆叠是作为执行线索的抓抓空间预留的内存。 当调用函数时, 在堆叠顶部保留一个区块, 用于本地变量和一些簿记数据。 当该函数返回时, 块会被未使用, 下次调用函数时可以使用。 堆叠总是保留在 LIFO 的顺序中( 最后一个在第一个出处) ; 最近保留的区块总是要解开的下一个区块 。 这样可以非常简单地跟踪堆叠; 从堆叠中释放一个区块只不过是调整一个指针而已 。

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

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

直接回答你的问题:

它们在多大程度上受到操作系统或语言运行时间的控制?

当线索创建时, OS 会为每个系统级线索分配书架。 通常情况下, OS 会被语言运行时间调用来分配应用程序的堆积 。

其范围是什么?

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

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

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

是什么让一个更快?

堆叠速度更快, 因为访问模式使得从堆叠中分配和处理内存变得微不足道( 指针/ 内插器仅仅是递增或衰减) , 而堆叠在分配或交易地点的簿记上复杂得多 。 此外, 堆叠中的每个字节往往会非常频繁地被再利用, 这意味着它往往被映射到处理器的缓存处, 使其速度非常快 。 堆积的另一个性能冲击是, 堆积( 大多是一个全球资源) , 通常必须是多读的安全性, 也就是说, 每一个分配和交易地点需要 — 通常 — 与程序中的“ 所有” 其它堆积权限同步 。

明确表明:
_{图像来源 :vikashazrati.wordpress.com 译者注:}

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

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

然而,一般而言最好考虑 " 。范围范围" 和 "寿命寿命而不是"堆"和"堆"

范围指代码中哪些部分可以访问变量。本地范围(只能由当前函数访问)和全球范围尽管范围可能变得更加复杂,但范围(无论何处都可以进入)仍会变得更加复杂。

寿命指变量在程序执行期间分配和交易的时间。通常我们想到的是静静分配(在程序的整个整个期间,将始终可变,因此有助于在多个函数调用中储存相同信息)相对于自动分配(只有在对函数的单一次呼叫中,可变性才能持续,使该函数可用于存储仅在您函数期间使用、一旦完成即可丢弃的信息)和动态分配(期限在运行时界定的可变数据,而不是静态或自动的时间。)

尽管大多数编译者和口译员在使用堆叠、堆肥等方面也采取了类似的做法,但只要行为正确,编译者有时会打破这些公约。例如,由于优化,本地变量可能只存在于一个登记册中,或者完全删除,即使大多数本地变量存在于堆叠中。正如在几个评论中指出的,您可以自由使用一个甚至不使用堆叠或堆积的编译者,而是使用其他一些存储机制(因为堆叠和堆积对这很重要,因为堆叠和堆积对这很重要 ) 。

我将提供一个简单的附加注释的 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++/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

其他人对大中风的反应也很好, 所以我要讲一些细节。

1. 堆放和堆放不需要是单数的 。 堆放和堆放的多处常见情况是, 您在一个过程中拥有多个线条。 在此情况下, 每个线条都有自己的堆放。 您也可以有多个堆放。 例如, 某些 DLL 配置可能导致不同堆放的 DLL 分配不同的 DLL , 这就是为什么释放不同图书馆分配的内存通常是一个坏主意 。

2. 在 C 中,您可以通过使用单花,它分配在堆叠上,而不是 Alloc,它分配在堆肥上。这个记忆不会保存在您的返回语句中,但它对刮痕缓冲很有用。

3. 在 Windows 上做一个不使用很多内容的大型临时缓冲区不是免费的。 这是因为编译器将生成一个堆叠探测器循环, 每次输入您的函数时都会被调用, 以确保堆叠存在( 因为 Windows在堆叠的末尾使用一个单个的守护页面来检测堆叠的生长需要。 如果您访问堆叠尾端的多页内存, 您将会崩溃 ) 。 例如 :

void myfunction()
{
   char big[10000000];
   // Do something that only uses for first 1K of big 99% of the time.
}