堆栈与堆（Stack vs Heap）：有什么区别？

编写有效的代码需要了解堆栈和堆内存，这使其成为学习编程的重要组成部分。不仅如此，新程序员或职场老手都应该完全熟悉堆栈内存和堆内存之间的区别，以便编写有效且优化的代码。

这篇博文将对这两种内存分配技术进行全面的比较。通过本文的结论，我们将对堆栈和堆内存有一个透彻的了解，从而使我们能够在编程工作中有效地使用它们。

对比理解堆栈与堆的结构！

内存分配

内存是计算机编程的基础。它提供了存储数据和程序高效运行所需的所有命令的空间。分配内存可以与在计算机内存中为特定目的指定特定区域进行比较，例如容纳对程序功能至关重要的变量或对象。程序的内存布局和组织可能会根据所使用的操作系统和体系结构而有所不同。然而，一般来说，内存可以分为以下几个部分：

• 全局段（Global segment）
• 代码段（Code segment）
• 堆栈（Stack）
• 堆（Heap）

全局段，负责存储全局变量和静态变量，这些变量的生命周期等于程序执行的整个持续时间。

代码段，也称为文本段，包含组成我们程序的实际机器代码或指令，包括函数和方法。

堆栈段，用于管理局部变量、函数参数和控制信息（例如返回地址）。

堆段，提供了一个灵活的区域来存储大型数据结构和具有动态生命周期的对象。堆内存可以在程序执行期间分配或释放。

注意：值得注意的是，内存分配上下文中的堆栈和堆不应与数据结构堆栈和堆混淆，它们具有不同的用途和功能。

四个内存段（全局、代码、堆栈和堆）的概述，说明了堆向下增长和堆栈向上增长的常规表示

每个程序都有自己的虚拟内存布局，由操作系统映射到物理内存。每个细分市场的具体分配取决于多种因素，例如：

• 程序代码的大小。
• 全局变量的数量和大小。
• 程序所需的动态内存分配量。
• 程序使用的调用堆栈的大小。

在任何函数外部声明的全局变量都将驻留在全局段中。程序功能和方法的机器代码或指令将存储在代码段中。让我们看一下编码示例，以帮助可视化全局和代码段在内存中的使用方式：

public class Main {
    // Global Segment：全局变量存放在这里
    static int globalVar = 42;
    
    // 代码段：这里存放函数和方法
    public static int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        // 代码段：调用add函数
        int sum = add(globalVar, 10);
        
        System.out.println("Sum: " + sum);
    }
}

Java 中的全局和代码段

globalVar在这些代码示例中，我们有一个值为 的全局变量42，它存储在全局段中。我们还有一个函数add，它接受两个整数参数并返回它们sum；该函数存储在代码段中。该main函数（或 Python 中的脚本）调用该add函数，传递全局变量和另一个整数值10作为参数。

代码中的全局和代码段（未显示堆和堆栈段）

需要强调的是，管理堆栈和堆段对于代码的性能和效率起着重要作用，使其成为编程的一个重要方面。因此，程序员在深入研究它们的差异之前应该充分理解它们。

栈内存：有序存储

将堆栈内存视为有组织且高效的存储单元。它使用后进先出 (LIFO) 方法，这意味着最近添加的数据将首先被删除。内核是操作系统的核心组件，自动管理堆栈内存；我们不必担心分配和释放内存。当我们的程序运行时，它会自行处理。

下面不同编程语言的代码实例演示了堆栈在各种情况下的使用。

public class StackExample {

    // 一个简单的函数来添加两个数字
    public static int add(int a, int b) {
        // 局部变量（存储在栈中）
        int sum = a + b;
        return sum;
    }

    public static void main(String[] args) {
        //  局部变量（存储在栈中）
        int x = 5;

        // 函数调用（存储在堆栈中）
        int result = add(x, 10);

        System.out.println("Result: " + result);
    }
}

Java 中的堆栈内存使用：演示局部变量和函数调用

调用函数时会创建称为堆栈帧的内存块。堆栈帧存储与局部变量、参数和函数的返回地址相关的信息。该内存是在堆栈段上创建的。

在上面的代码实例中，我们创建了一个名为 的函数add。该函数采用两个参数作为输入整数并返回它们的sum. 在函数内部add，我们创建了一个局部变量调用sum来存储结果。该变量存储在堆栈内存中。

在main函数（或 Python 的顶级脚本）中，我们创建另一个局部变量x并为其分配值5。该变量也存储在堆栈内存中。x然后，我们以和作为参数调用 add 函数10。函数调用及其参数和返回地址都放置在堆栈中。一旦add函数返回，堆栈就会被弹出，删除函数调用和关联的数据，我们可以打印结果。

在下面的解释中，我们将介绍运行每行重要代码后堆和堆栈如何变化。尽管我们用的的是 C++，但对 Python 和 Java 的解释也同样适用。我们在这里只讨论堆栈段。

堆栈段为空

1共 9 个

为主函数创建一个新的堆栈帧

2共 9 个

在 main 函数的堆栈帧中，局部变量 x 现在的值为 5

3共 9 个

调用 add 函数，实际参数为 (5, 10)

4共 9 个

控制权转移到 add 函数，为 add 函数创建一个新的堆栈帧，其中包含局部变量 a、b 和 sum

5共 9 个

add 函数的堆栈帧上的 sum 变量被分配 a + b 的结果

6共 9 个

add 函数完成其任务并且其堆栈帧被销毁

7共 9 个

具有可变结果的主函数的堆栈帧存储从 add 函数返回的值

8共 9 个

在显示结果值（此处未显示）后，主功能块也被销毁，并且堆栈段再次为空

9共9 个

以下是 C++ 代码按执行顺序的解释：

• 第 10 行：程序从该main函数开始，并为其创建一个新的堆栈帧。
• 第 12 行：局部变量x被赋值为5。
• 第 15 行：add使用参数x和调用该函数10。
• 第 4 行：为该函数创建一个新的堆栈帧add。控制权转移到add带有局部变量的函数。a、b、 和sum。变量a和分别被赋予和b的值。x10
• 第 6 行：局部变量sum被赋值为a + b（即 5 + 10）。
• 第 7 行：变量sum的值（即 15）被返回给调用者。
• 第 8 行：add从堆栈中弹出函数的堆栈帧，并释放所有局部变量（、和a） b。sum
• 第15行：result函数堆栈帧上的局部变量main被赋予返回值（即15）。
• 第 17 行：存储在变量中的值result（即 15）使用 打印到控制台std::cout。
• 第 19 行：函数main返回 0，表示执行成功。
• 第 20 行：函数main的堆栈帧从堆栈中弹出，并且所有局部变量 (x和result) 都被释放。

堆栈存储器的主要特点

以下是有关堆栈内存需要考虑的一些关键方面：

• 固定大小：当涉及到堆栈内存时，其大小保持固定，并在程序执行开始时确定。
• 速度优势：堆栈内存帧是连续的。因此，在堆栈内存中分配和释放内存的速度非常快。这是通过操作系统管理的堆栈指针对引用进行简单调整来完成的。
• 控制信息和变量的存储：堆栈内存负责容纳控制信息、局部变量和函数参数，包括返回地址。
• 有限的可访问性：请务必记住，存储在堆栈内存中的数据只能在活动函数调用期间访问。
• 自动管理：堆栈内存的高效管理由系统本身完成，不需要我们额外的工作。

堆内存：动态存储

堆内存，也称为动态内存，是内存分配的野孩子。程序员必须手动管理它。堆内存允许我们在程序执行期间随时分配和释放内存。它非常适合存储大型数据结构或大小事先未知的对象。

下面不同编程语言的代码实例演示了堆的使用。

public class HeapExample {
    public static void main(String[] args) {
        // 栈：局部变量“value”存储在 栈中
        int value = 42;

        // 堆：为堆上的单个 Integer 分配内存
        Integer ptr = new Integer(value);

        // 将值分配给分配的内存并打印它
        System.out.println("Value: " + ptr);

        // 在Java中，垃圾收集是自动的，因此不需要 释放内存
      
    }
}

演示 Java 中的堆内存分配和使用

在这些代码示例中，目标是将值存储42在堆内存中，这是一个更永久、更灵活的存储空间。这是通过使用驻留在堆栈内存中的指针或引用变量来完成的：

• int* ptr在C++中。
• Java 中的一个Integer对象ptr。
• ptrPython 中包含单个元素的列表。

然后打印存储在堆上的值。在C++中，需要使用delete关键字手动释放堆上分配的内存。然而，Python 和 Java 通过垃圾收集自动管理内存释放，无需手动干预。

注意：在 Java 和 Python 中，垃圾收集会自动处理内存释放，无需手动释放内存，如 C++ 中所示。

在下面的解释中，我们将讨论运行每行重要代码后堆和堆栈如何变化。尽管我们关注的是 C++，但该解释也适用于 Python 和 Java。我们在这里只讨论堆栈和堆段。

栈段和堆段为空

1共 7 个

为主函数创建一个新的堆栈帧

2共 7 个

局部变量值被赋予值 42

3共 7 个

在堆上分配了一个指针变量ptr，指针ptr中存放的是分配的堆内存的地址（即0x1000）

4共 7 个

value变量中存储的值（即42）被赋值给ptr指向的内存位置（堆地址0x1000）

5共 7 个

堆上地址 0x1000 处分配的内存被释放

6共 7 个

main函数的栈帧从栈中弹出（显示result的值后），栈段和堆段再次清空

7共7 个

以下是 C++ 代码按执行顺序的解释：

• 第 3 行：main调用该函数，并为其创建一个新的堆栈帧。
• 第 5 行：堆栈帧上的局部变量value被赋值为42。
• 第 8 行：ptr使用关键字为堆上的单个整数动态创建的内存分配给指针变量new。我们假设堆上新内存的地址为 0x1000。分配的堆内存的地址（0x1000）存储在指针中。ptr。
• 第 11 行：将整数值42分配给ptr（堆地址 0x1000）所指向的内存位置。
• 第 12 行：(ptr )指向的内存位置存储的值42被打印到控制台。
• 第 15 行：使用关键字释放在堆上地址 0x1000 处分配的内存delete。在此行之后，ptr成为悬空指针，因为它仍然保存地址 0x1000，但该内存已被释放。然而，对于这个重要的讨论，我们不会详细讨论悬空指针。
• 第17行：
• 第 18 行：从堆栈中弹出主函数的堆栈帧，并释放所有局部变量 (value和)。ptr

注意：C++ 标准库还提供了一系列智能指针，可以帮助自动化堆中内存分配和释放的过程。

堆内存的主要特点

以下是需要记住的堆内存的一些显着特征：

• 大小的灵活性：堆内存大小可以在程序执行过程中发生变化。
• 速度权衡：在堆中分配和释放内存速度较慢，因为它涉及寻找合适的内存帧和处理碎片。
• 动态对象的存储：堆内存存储具有动态生命周期的对象和数据结构，如newJava 或 C++ 中使用关键字创建的对象和数据结构。
• 持久数据：存储在堆内存中的数据将一直保留在那里，直到我们手动释放它或程序结束。
• 手动管理：在某些编程语言（例如C和C++）中，必须手动管理堆内存。如果处理不当，可能会导致内存泄漏或资源使用效率低下。

堆栈与堆：差异对比

现在我们彻底了解了堆栈和堆内存分配的工作原理，我们可以区分它们了。在比较栈内存和堆内存时，我们必须考虑它们的独特特性来理解它们的差异：

• 大小管理：堆栈内存具有在程序执行开始时确定的固定大小，而堆内存是灵活的，可以在程序的整个生命周期中更改。
• 速度：堆栈内存在分配和释放内存时具有速度优势，因为它只需要调整引用。相反，由于需要定位合适的内存帧并管理碎片，堆内存操作速度较慢。
• 存储目的：堆栈内存指定用于控制信息（例如函数调用和返回地址）、局部变量和函数参数（包括返回地址）。另一方面，堆内存用于存储具有动态生命周期的对象和数据结构，例如newJava 或 C++ 中使用关键字创建的对象和数据结构。
• 数据可访问性：堆栈内存中的数据只能在活动函数调用期间访问，而堆内存中的数据在手动释放或程序结束之前仍然可以访问。
• 内存管理：系统自动管理堆栈内存，优化其使用，以实现快速高效的内存引用。相比之下，堆内存管理是程序员的责任，处理不当可能会导致内存泄漏或资源使用效率低下。

下表总结了堆栈内存和堆内存在不同方面的主要区别：

堆栈内存与堆内存：何时使用每种类型

我们现在知道堆栈内存和堆内存之间的区别。现在让我们看看何时使用每种类型的内存。

堆栈是 C++、Java 和 Python 中存储局部变量和函数参数的默认选项，其生命周期较短且可预测。但在以下情况下建议使用堆内存：

• 当需要存储对象、数据结构或动态分配的数组时，其生命周期在编译时或函数调用期间无法预测。
• 当内存需求很大或者我们需要在程序的不同部分之间共享数据时。
• 当需要分配超出单个函数调用范围的内存时。

此外，C++ 中需要手动内存管理（使用delete），而在 Java 和 Python 中，内存释放主要通过垃圾回收来处理。尽管如此，我们还是应该注意内存使用模式以避免出现问题。

结论

对于任何寻求编写高效且优化的代码的程序员来说，了解堆栈内存和堆内存之间的差异至关重要。

堆栈内存最适合临时存储、局部变量和函数参数。

堆内存非常适合大型数据结构和具有动态生命周期的对象。

我们需要谨慎选择合适的内存分配方法；我们可以创建高效且性能良好的程序。

每种类型的内存都有其自己的一组功能，使用它们来确保我们软件的性能和资源利用率至关重要。