第3章 内存管理

对于来自 Python、JavaScript 或 Go 等高级语言的开发者来说，手动内存管理往往是一个令人生畏的概念。即便是有 C++ 经验的开发者，Zig 的内存管理方式也会让你耳目一新。

在大多数现代语言中，内存管理要么是全自动的（通过垃圾回收器 GC），要么是隐式的（通过构造函数/析构函数）。而在 Zig 中，内存管理是显式且手动的。Zig 没有隐藏的内存分配，也没有默认的全局分配器。如果一个函数需要分配内存，它通常会要求你显式传入一个分配器 (Allocator)。

本章将带你深入 Zig 内存管理的核心，解析堆与栈的区别，并掌握 Zig 独特的分配器模式。

计算机内存模型：堆与栈

在深入 Zig 语法之前，我们需要先复习一下计算机程序使用内存的两种主要方式：栈 (Stack) 和 堆 (Heap)。

1. 栈 (The Stack)

栈是内存管理中最快、最简单的部分。

• 工作原理：栈是一块预留的连续内存区域，遵循 LIFO（后进先出）原则。
• 分配与释放：非常快。分配内存只需移动栈指针（Stack Pointer），释放内存只需将指针移回。
• 用途：存储局部变量、函数参数、返回地址等。
• 生命周期：由作用域决定。当函数执行结束或离开作用域时，栈上的数据会自动被“弹出”销毁。
• 限制：
  1. 大小有限：栈空间通常很小（几 MB）。
  2. 大小固定：存放在栈上的数据，其大小必须在编译时确定（Compile-time known size）。你不能在栈上创建动态大小的数组。

fn stackExample() void {
    const x: i32 = 42; // x 存储在栈上
    var array: [10]u8 = undefined; // 固定大小数组，存储在栈上
}
// 函数结束，x 和 array 自动销毁

2. 堆 (The Heap)

堆是用于动态内存分配的区域。

• 工作原理：堆是一块巨大的、杂乱的内存池。
• 分配与释放：较慢。分配时需要寻找足够大的空闲块，释放时需要标记该块为可用。
• 用途：存储动态大小的数据（如可变长度数组、树、图）、生命周期跨越多个函数调用的数据。
• 生命周期：完全由程序员手动控制。你申请（alloc）内存，就必须负责释放（free）它。
• 风险：
  1. 内存泄漏：忘记释放内存。
  2. Use-After-Free：使用了已释放的内存。
  3. Double-Free：重复释放同一块内存。

Zig 的核心哲学之一就是帮助你更好地管理堆内存，减少上述风险。

Zig 的分配器 (Allocators)

在 C 语言中，我们习惯直接调用 malloc 和 free。这两个函数使用的是 libc 的全局分配器。这意味着你在代码的任何地方都在隐式地使用同一个内存管理器。

Zig 采取了完全不同的策略：没有默认的全局分配器。

如果一个函数需要在堆上分配内存，按照惯例，它必须接受一个 std.mem.Allocator 类型的参数。这种设计被称为“显式分配器传递”。

为什么要这样设计？

1. 透明性：你看一眼函数签名，就知道它是否会分配内存。没有隐藏的 malloc。
2. 灵活性：你可以根据不同的需求传入不同的分配器。例如：
   • 对于短生命周期任务，使用高性能的 ArenaAllocator。
   • 对于测试，使用能检测泄漏的 TestingAllocator。
   • 对于受限环境，使用固定缓冲区的 FixedBufferAllocator。

标准库中的分配器

Zig 标准库 (std.heap) 提供了多种现成的分配器：

1. std.heap.page_allocator

这是最底层的分配器。它直接向操作系统申请整个内存页（Page）。

• 优点：简单，无需初始化。
• 缺点：对于小对象的分配非常浪费且低效（每次至少申请 4KB）。

2. std.heap.GeneralPurposeAllocator (GPA)

这是一个通用的、高性能的、线程安全的分配器。它类似于 libc 的 malloc，但设计得更现代。

• 特点：具备内存泄漏检测功能（在 Debug 模式下）。通常作为程序的主分配器。

var gpa = std.heap.GeneralPurposeAllocator(.{}){};
const allocator = gpa.allocator();
deffer _ = gpa.deinit(); // 程序结束时释放 GPA 并检查泄漏

3. std.heap.ArenaAllocator

竞技场分配器（Arena Allocator）是一种非常高效的策略。

• 工作原理：它申请一大块内存，然后在其上进行线性分配。
• 释放：你不需要释放单个对象。当你销毁 Arena 时，它会一次性释放所有内存。
• 用途：适合处理请求/响应周期，或构建树/图结构。

4. std.heap.FixedBufferAllocator

固定缓冲区分配器。

• 工作原理：它不向操作系统申请内存，而是使用你提供的一块固定内存（通常是栈上的数组）。
• 优点：极快，无系统调用，零堆分配。
• 缺点：内存用完即止，会返回 OutOfMemory 错误。

实践：如何使用分配器

让我们通过一个例子来看看如何在堆上分配内存。我们将使用 allocator.alloc 来创建一个动态数组。

const std = @import("std");

pub fn main() !void {
    // 1. 初始化分配器 (这里使用 GPA)
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    
    // 确保在程序结束时释放 GPA 资源，并检查是否有未释放的内存
    defer {
        const deinit_status = gpa.deinit();
        if (deinit_status == .leak) @panic("Memory leak detected!");
    }

    // 2. 在堆上分配内存
    // 申请一个能存 3 个 u32 的切片
    const slice = try allocator.alloc(u32, 3);
    
    // 3. 重要：使用 defer 确保释放！
    // 这里的 defer 会在 main 函数退出时执行
    defer allocator.free(slice);

    // 4. 使用内存
    slice[0] = 10;
    slice[1] = 20;
    slice[2] = 30;

    std.debug.print("Slice: {any}
", .{slice});
}

关键步骤解析：

1. allocator.alloc(T, n)：申请能容纳 n 个 T 类型元素的内存。返回一个切片 []T。如果是单个对象，可以使用 create(T)，返回指针 *T。
2. try：内存分配可能会失败（例如内存耗尽），所以必须用 try 处理潜在的 OutOfMemory 错误。
3. defer allocator.free(slice)：这是 Zig 内存管理的黄金法则。在分配内存的下一行，立即写上 defer free。 这样可以保证无论后续逻辑如何（即使发生错误提前返回），内存都能被正确释放。

编译时 (Comptime) 与运行时 (Runtime)

理解 Zig 内存管理的另一个关键是区分编译时和运行时。

• 编译时 (Comptime)：在代码编译阶段就知道的信息。
• 运行时 (Runtime)：程序运行起来后才知道的信息。

为什么这很重要？

因为 Zig 对这两种状态的处理方式截然不同。

• 数组 (Array) 的大小必须是编译时已知的。例如 [4]u8，编译器需要知道它占用多少栈空间。
• 如果你的数据大小取决于用户的输入（即运行时才能确定），你就不能使用数组，而必须使用切片 (Slice) 并分配在堆上。

// 编译时已知大小：数组
const array = [3]u8{1, 2, 3}; 

// 运行时大小：切片 (指向堆内存)
const runtime_len = getLengthFromUser();
const slice = try allocator.alloc(u8, runtime_len);
defer allocator.free(slice);

Comptime 关键字

Zig 的 comptime 关键字非常强大。它允许你在编译阶段执行任意的 Zig 代码。

fn fibonacci(n: u32) u32 {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

pub fn main() !void {
    // 这段代码会在编译期间运行！
    // 编译器会计算出结果 55，并将其硬编码到最终的二进制文件中。
    const result = comptime fibonacci(10);
    
    std.debug.print("Result: {d}
", .{result});
}

这不仅用于优化，还是 Zig 实现泛型（Generics）的基础。我们将在后续章节详细讨论泛型。

总结

Zig 的内存管理哲学可以概括为：显式优于隐式，控制权归于开发者。

1. 没有全局分配器：函数若需分配内存，必须显式接收 Allocator 参数。
2. 手动管理：谁分配（alloc），谁释放（free）。defer 是你的好帮手。
3. 区分堆栈：固定大小用栈（数组），动态大小用堆（切片+分配器）。
4. 安全网：Debug 模式下的 GPA 分配器会帮你检测内存泄漏，这是 Zig 提供的强大安全保障。

掌握了内存管理，你就掌握了 Zig 真正的力量。下一章，我们将利用这些知识，实战构建一个 Base64 编码器。

---

原文出处 : https://pedropark99.github.io/zig-book/