跳转到内容
语言参考Zig 0.17.1官方原文

Zig 语言不替程序员管理内存,因此 Zig 不需要运行时支持,也能在实时软件、操作系统内核、嵌入式设备及低延迟服务器等多种环境中无缝工作。相应地,Zig 程序员必须始终能够回答以下问题:

字节位于何处?

与 Zig 一样,C 语言也手动管理内存。但 C 具有默认分配器 malloc、realloc 和 free,Zig 则不同。链接 libc 时,Zig 通过 std.heap.c_allocator 暴露这一分配器。但按照约定,Zig 没有默认分配器:需要分配内存的函数接受一个 Allocator 参数;同样,一些数据结构的初始化函数接受 Allocator 参数:

test_allocator.zig
const std = @import("std");
const Allocator = std.mem.Allocator;
const expectEqualStrings = std.testing.expectEqualStrings;
test "using an allocator" {
var buffer: [100]u8 = undefined;
var fba = std.heap.FixedBufferAllocator.init(&buffer);
const allocator = fba.allocator();
const result = try concat(allocator, "foo", "bar");
try expectEqualStrings("foobar", result);
}
fn concat(allocator: Allocator, a: []const u8, b: []const u8) ![]u8 {
const result = try allocator.alloc(u8, a.len + b.len);
@memcpy(result[0..a.len], a);
@memcpy(result[a.len..], b);
return result;
}
命令行
$ zig test test_allocator.zig
1/1 test_allocator.test.using an allocator...OK
All 1 tests passed.

上例使用 100 字节栈内存初始化 FixedBufferAllocator,随后将其传给函数。为便于快速测试,std.testing.allocator 处提供了全局 FixedBufferAllocator,还会进行基本的泄漏检测。

Zig 提供通用分配器,可通过 std.heap.DebugAllocator 导入。不过仍建议遵循选择分配器指南。

选择分配器

选择分配器取决于多种因素,以下判断流程可帮助决定:

  1. 正在编写库?此时最好接受 Allocator 参数,让库的使用者决定采用哪种分配器。
  2. 正在链接 libc?此时 std.heap.c_allocator 很可能是合适选择,至少适合作为主分配器。
  3. 所需最大字节数是否有一个在编译时已知的上界?如果有,使用 std.heap.FixedBufferAllocator。
  4. 程序是否是从头运行至结束的命令行应用,没有游戏主循环、Web 服务器请求处理器等基本循环模式,因而适合在最后一次性释放所有内容?此时建议采用以下模式:
    cli_allocation.zig
    const std = @import("std");
    pub fn main() !void {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();
    const allocator = arena.allocator();
    const ptr = try allocator.create(i32);
    std.debug.print("ptr={*}\n", .{ptr});
    }
    命令行
    $ zig build-exe cli_allocation.zig
    $ ./cli_allocation
    ptr=i32@7d55493a1018
    使用此类分配器时,无须手动释放任何对象。调用 arena.deinit() 会一次性释放全部内容。
  5. 分配是否属于游戏主循环、Web 服务器请求处理器等循环模式?如果可以在周期结束时一次性全部释放,例如渲染完一帧或处理完一个请求之后,std.heap.ArenaAllocator 是很好的选择。如前一条所示,它允许一次释放整个内存区域。还应注意,如果能够确定内存上界,可以使用 std.heap.FixedBufferAllocator 进一步优化。
  6. 正在编写测试,且要确保正确处理 error.OutOfMemory?此时使用 std.testing.FailingAllocator。
  7. 正在编写测试?此时使用 std.testing.allocator。
  8. 最后,如果以上条件都不适用,就需要通用分配器。在 debug 模式下,可以使用 std.heap.DebugAllocator:它接收在编译时已知的配置结构体,并返回一个类型。通常在 main 函数中只创建一个,再将它或其子分配器传递到应用各部分。
  9. 在 fast 模式编译时,std.heap.smp_allocator 是可靠的通用分配器选择。
  10. 也可以考虑自行实现分配器。

字节位于何处?

"hello" 等字符串字面量位于全局常量数据段。因此,将字符串字面量传给可变切片会产生错误,例如:

test_string_literal_to_slice.zig
fn foo(s: []u8) void {
_ = s;
}
test "string literal to mutable slice" {
foo("hello");
}
命令行
$ zig test test_string_literal_to_slice.zig
/home/alexrp/Sources/ziglang/zig/doc/langref/test_string_literal_to_slice.zig:6:9: error: expected type '[]u8', found '*const [5:0]u8'
foo("hello");
^~~~~~~
/home/alexrp/Sources/ziglang/zig/doc/langref/test_string_literal_to_slice.zig:6:9: note: cast discards const qualifier
/home/alexrp/Sources/ziglang/zig/doc/langref/test_string_literal_to_slice.zig:1:11: note: parameter type declared here
fn foo(s: []u8) void {
^~~~

但如果将切片改为常量,就可以正常工作:

test_string_literal_to_const_slice.zig
fn foo(s: []const u8) void {
_ = s;
}
test "string literal to constant slice" {
foo("hello");
}
命令行
$ zig test test_string_literal_to_const_slice.zig
1/1 test_string_literal_to_const_slice.test.string literal to constant slice...OK
All 1 tests passed.

与字符串字面量一样,值在编译时已知的 const 声明存储在全局常量数据段。编译时变量也存储在全局常量数据段。

函数内部的 var 声明存储在函数栈帧中。函数返回后,所有指向其栈帧内变量的指针都成为无效引用,解引用会导致不进行检查的非法行为。

顶层或 struct 声明中的 var 声明存储在全局数据段。

通过 allocator.alloc 或 allocator.create 分配的内存位置,由分配器实现决定。

待补充:线程局部变量

堆分配失败

许多编程语言选择在堆分配失败时无条件崩溃。按照约定,Zig 程序员不认为这是令人满意的解决方案。Zig 使用 error.OutOfMemory 表示堆分配失败;当堆分配失败阻止某项操作成功完成时,Zig 库会返回该错误码。

有人认为,Linux 等部分操作系统默认启用内存过量承诺,因此处理堆分配失败没有意义。这种推理存在多个问题:

  • 只有部分操作系统支持内存过量承诺。
    • Linux 默认启用,但可以配置。
    • Windows 不采用内存过量承诺。
    • 嵌入式系统没有内存过量承诺。
    • 个人兴趣开发的操作系统可能支持,也可能不支持内存过量承诺。
  • 实时系统不仅没有内存过量承诺,通常还会预先确定每个应用的最大内存量。
  • 编写库的主要目标之一是代码复用。正确处理分配失败,可以让库在更多场景中复用。
  • 虽然有些软件已依赖内存过量承诺,但这一机制导致了无数糟糕的用户体验。默认配置的 Linux 等启用过量承诺的系统接近内存耗尽时,会陷入停顿而无法使用。此时,内存不足终止器通过启发式规则选择要终止的应用。其不确定性常常导致重要进程被终止,而且经常无法让系统恢复正常。

递归

递归是软件建模的基本工具,但有一个常被忽视的问题:无界内存分配。

Zig 对递归仍在积极探索,因此此处文档尚未定稿。可以阅读 0.3.0 发行说明中的递归状态总结。

简要而言,当前递归按通常预期工作。Zig 代码目前尚不能防止栈溢出,但计划在未来版本中提供此保护,并要求 Zig 代码进行一定程度的配合。

生命周期与所有权

Zig 程序员有责任保证:指针所指内存不再可用时,不再通过该指针访问。注意,切片也属于引用其他内存的指针形式。

处理指针时可以遵循一些有助于避免错误的约定。通常,函数返回指针时,文档应说明谁“拥有”该指针。所有权概念帮助程序员决定是否需要释放该指针,以及何时释放。

例如,函数文档可能写明“调用者拥有返回的内存”,此时调用该函数的代码必须规划何时释放这块内存。该函数很可能接收 Allocator 参数。

有时指针生命周期更复杂。例如,std.ArrayList(T).items 切片会保持有效,直到列表下一次调整大小,例如追加新元素时。

函数和数据结构的接口文档应仔细解释指针的所有权与生命周期语义。所有权决定谁负责释放指针引用的内存,生命周期决定内存何时变得不可访问,否则会发生非法行为。