103.别再死记栈和堆了！3分钟用生活化例子讲透，新手一听就懂，再也不踩坑

一、先讲栈：一块有固定规矩的内存区域

其实栈就是一块内存区域，用起来有固定规矩，最核心的特点就是后进先出。说白了，你就把它想成家里那一摞盘子：最后放上去的那个，肯定最先被拿走；最早放的那个，反倒得等最后才能取。这就是后进先出的意思，特别好记！

程序调用函数跟放盘子的逻辑一模一样！举个例子，main函数调用A函数，A函数又调用B函数，那就是main先进栈，接着A进来，最后B再进来。等程序执行完，B最先出栈，然后是A，最后才回到main，一步都不会乱，系统会自动帮你理清楚顺序！

每调用一次函数，系统就会在栈上给它划一块专属空间，这就是栈帧。这里面会存什么呢？很简单，函数的参数、局部变量、返回地址，还有程序运行时需要的状态信息，全在这！比如你写个加法函数add，参数a、b，还有里面的局部变量result，全都存在栈帧里，不用你手动管。

栈的优势

栈的好处真的太突出了：

1. 管理特别简单：完全不用你手动操心，函数一调用，系统自动分配空间；函数一执行完，系统又自动回收，零管理成本，新手友好到爆！
2. 速度贼快：因为栈的内存排列得整整齐齐，系统只需要调一下指针，就能完成分配和释放，比堆快多了！

栈的致命缺点：空间有限

但栈也有个致命缺点——空间有限！要是函数调用的层级太深，或者你在函数里创建了特别大的局部变量，把栈的空间占满了，就会出现栈溢出！最常见的就是递归函数，要是没写结束条件，它就会不停调用自己，栈帧越堆越多，最后直接报错stack overflow。

所以写递归的时候，一定要记得加结束条件，别踩这个坑！

二、再讲堆：专门用来动态分配内存的区域

说完栈，咱们再讲堆！这里说的堆和栈完全不是一回事，它就是程序运行时，专门用来动态分配内存的区域。什么时候用堆呢？很简单，只要你不知道要存的数据有多大，或者数据需要长期保存，就找堆准没错！

给你们举两个例子，一看就懂：

1. 场景一：文件读取：你要读一个文件，写代码的时候根本不知道文件有多大，这时候就可以根据文件的实际大小，从堆里动态申请内存，用多少申请多少。
2. 场景二：跨函数对象：一个对象，你在这个函数里用完，其他函数还得接着用，那它就不能放栈里，因为函数一结束，栈里的数据就被回收了。这时候放堆里，就能一直保留着。

堆的优势与代价

堆最大的优势就是空间大、用起来灵活，不管是大块数据，还是生命周期不确定的数据，都能往堆里放。但灵活归灵活，它的管理成本可比栈高多了，稍不注意就会出问题！

就拿C、C++来说，你用malloc、new申请了堆内存，用完之后必须手动用free、delete释放掉，不然就会出现内存泄露！什么是内存泄露？说白了，就是这块内存已经没用了，你却没还给系统。一次两次可能看不出来问题，但程序要是长期运行，不停申请内存又不释放，内存就会越占越多，最后直接崩溃，特别麻烦！

可能有兄弟会说，Java、Go这些语言就不用操心了吧？确实，它们有垃圾回收机制，也就是GC，不用你手动释放，会自动回收那些没用的堆内存。但别觉得就万事大吉了！如果你一直留着那些没用对象的引用，GC就会误以为它还能用，不会回收，时间长了，内存照样会越占越大，还是会出问题！

三、4点核心区别，新手直接抄作业

最后给大家总结4点核心区别，记好这4点，再也不会把栈和堆搞混，新手直接抄作业！

第一，管理方式不一样

• 栈：系统全权负责，自动分配、自动释放，你啥都不用管。
• 堆：得动态申请，C、C++需要你手动释放；Java、Go这些语言靠GC自动管理，相对省心一点，但也不能完全不管。

第二，生命周期不一样

• 栈：栈里的数据，完全跟着函数走，函数执行完，对应的栈帧就被销毁，数据也没了。
• 堆：堆里的数据不一样，只要你还保留着它的引用，就能一直存在，就算跨函数使用也没问题。

第三，空间大小不一样

• 栈：栈的空间比较小，就适合存点临时数据，比如函数参数、局部变量这些。
• 堆：堆的空间就大得多，适合存对象、大块数据，还有那些生命周期不确定的数据。

第四，速度不一样

• 栈：栈的结构简单，内存排列规整，分配和释放的速度特别快。
• 堆：堆就不一样了，系统得找空闲的内存，还要处理内存碎片、垃圾回收这些事，速度慢，管理成本也高。

四、大白话总结，彻底分清

用一句大白话总结，大家就能彻底分清：

• 栈：就像函数的临时工作台，空间不大，但用起来方便、速度快，用完还不用自己收拾，系统自动清理。
• 堆：就像程序的公共仓库，空间大、想怎么用就怎么用，但得精心打理，不然就容易出问题！

五、代码示例，直观理解

为了让大家更直观地理解，我准备了几个代码示例，覆盖栈溢出、内存泄漏、栈帧和函数调用等场景。

示例1：栈溢出（递归）

#include <stdio.h>

// 错误示例：没有结束条件，无限递归，导致栈溢出
void infinite_recursion() {
    printf("递归调用...\n");
    infinite_recursion(); // 没有结束条件，一直调用自己
}

// 正确示例：有结束条件的递归
int factorial(int n) {
    if (n <= 1) { // 结束条件
        return 1;
    }
    return n * factorial(n - 1);
}

int main() {
    // 测试正确的递归
    printf("5的阶乘是：%d\n", factorial(5)); // 输出：120
    
    // 测试错误的递归（会导致栈溢出）
    // infinite_recursion(); // 取消注释，运行会报错 stack overflow
    
    return 0;
}

示例2：内存泄漏（C++）

#include <iostream>

// 错误示例：内存泄漏，忘记释放堆内存
void memory_leak() {
    int* ptr = new int(42); // 申请堆内存
    // 忘记 delete ptr; 函数结束，指针丢失，内存泄漏
}

// 正确示例：手动释放堆内存
void no_memory_leak() {
    int* ptr = new int(42);
    std::cout << *ptr << std::endl;
    delete ptr; // 释放堆内存
}

int main() {
    memory_leak(); // 内存泄漏
    no_memory_leak(); // 没有内存泄漏
    return 0;
}

示例3：栈帧和函数调用（C）

#include <stdio.h>

// 加法函数，参数a、b，局部变量result，都存在栈帧里
int add(int a, int b) {
    int result = a + b;
    return result;
}

int main() {
    int x = 10;
    int y = 20;
    int sum = add(x, y); // 调用add函数，main函数的栈帧里保存了返回地址等信息
    printf("sum = %d\n", sum); // 输出：30
    return 0;
}

示例4：堆的使用场景（Java）

public class HeapExample {
    static class Person {
        String name;
        int age;
        
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    }
    
    public static void main(String[] args) {
        // 对象存在堆里，引用存在栈里
        Person person = new Person("张三", 25); 
        System.out.println(person.name + "，" + person.age + "岁");
        
        // 数组存在堆里
        int[] numbers = new int[1000]; 
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] = i;
        }
    }
}

怎么样？是不是一下子就懂了？栈和堆其实没那么难，只要搞懂它们的本质，那些内存相关的报错，全都能轻松解决！

如果这篇文章对你有帮助，欢迎点赞、收藏、转发，也欢迎在评论区留下你的问题，我们一起交流学习！