为什么Zig中不用inline循环创建Trie树会失败？

问题重现 #

尝试用Zig的StringHashMap实现Trie结构，使用inline for循环时能正常构建预期的树结构，但移除inline关键字后，构建的Trie不符合预期，具体代码及输出如下：

原始代码 #

const std = @import("std");
const Allocator = std.mem.Allocator;
const print = std.debug.print;
const expect = std.testing.expect;

const HashMap = struct {
    value: u8,
    children: std.StringHashMap(*HashMap),
};

fn newHashMap(allocator: Allocator, value: u8) HashMap {
    return HashMap{
        .value = value,
        .children = std.StringHashMap(*HashMap).init(allocator),
    };
}

fn showTree(root: *std.StringHashMap(*HashMap), keys:[3][]const u8 ) void {
    var hashMap = root;
    for (keys) |key| {
        print("get key {s}\n", .{key});
        var value = hashMap.get(key);
        if (value) |node| {
            print("we got a value for {s}:{}\n", .{key,node.value});
            hashMap = &node.children;
        } else {
            print("no value for {s}\n", .{key});
            break;
        }
    }
}

test "HashMap" {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const gpaAllocator = gpa.allocator();
    var arena = std.heap.ArenaAllocator.init(gpaAllocator);
    defer {
        arena.deinit();
        const leaked = gpa.deinit();
        if (leaked) expect(false) catch @panic("TEST FAIL");
    }

    const allocator = arena.allocator();
    var root = &std.StringHashMap(*HashMap).init(allocator);
    var hashMap = root;
    const keys = [_][]const u8{ "a", "b", "c" };
    const values: [3]u8 = .{ 1, 2, 3 };
  
    // create tree
    inline for (keys) |key, i| {
        print("put key {s}:{}\n", .{ key, values[i] });
        var newNode = newHashMap(allocator, values[i]);
        try hashMap.put(key, &newNode);
        showTree(root,keys);
        hashMap = &newNode.children;
    }
   
    showTree(root,keys);
}

正常输出（带inline） #

Test [1/1] test "HashMap"... 
put key a:1
put key b:2
put key c:3
get key a
we got a value for a:1
get key b
we got a value for b:2
get key c
we got a value for c:3
All 1 tests passed.

异常输出（移除inline） #

Test [1/1] test "HashMap"... 
put key a:1
put key b:2
put key c:3
get key a
we got a value for a:3
get key b
no value for b
All 1 tests passed.

问题原因 #

核心问题在于栈变量的生命周期与指针引用不匹配：

• 使用inline for时，编译器会把循环展开为三次独立的代码块，每次循环中的newNode都是独立的栈局部变量，各自拥有独立的内存地址，因此存入HashMap的指针指向的是不同的有效栈位置。
• 移除inline后，普通循环中newNode是同一个栈位置，每次循环都会覆盖这个变量的内容。HashMap中存储的指针始终指向这个栈位置，最终所有指针都会指向最后一次循环赋值的newNode（值为3）。同时，每次循环覆盖newNode时，之前节点的children HashMap也会被覆盖，导致子节点丢失，出现"no value for b"的错误。

解决方案 #

必须在堆上分配HashMap实例，确保每个节点的内存地址在循环结束后依然有效，而非依赖栈变量。修改代码如下：

修正后的代码 #

const std = @import("std");
const Allocator = std.mem.Allocator;
const print = std.debug.print;
const expect = std.testing.expect;

const HashMap = struct {
    value: u8,
    children: std.StringHashMap(*HashMap),

    // 在堆上创建节点的方法
    fn init(allocator: Allocator, value: u8) !*HashMap {
        var node = try allocator.create(HashMap);
        node.* = HashMap{
            .value = value,
            .children = std.StringHashMap(*HashMap).init(allocator),
        };
        return node;
    }

    // 递归清理节点资源
    fn deinit(self: *HashMap, allocator: Allocator) void {
        var iter = self.children.iterator();
        while (iter.next()) |entry| {
            entry.value_ptr.*.deinit(allocator);
        }
        self.children.deinit();
        allocator.destroy(self);
    }
};

fn showTree(root: *std.StringHashMap(*HashMap), keys:[3][]const u8 ) void {
    var hashMap = root;
    for (keys) |key| {
        print("get key {s}\n", .{key});
        var value = hashMap.get(key);
        if (value) |node| {
            print("we got a value for {s}:{}\n", .{key,node.value});
            hashMap = &node.children;
        } else {
            print("no value for {s}\n", .{key});
            break;
        }
    }
}

test "HashMap" {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const gpaAllocator = gpa.allocator();
    var arena = std.heap.ArenaAllocator.init(gpaAllocator);
    defer {
        arena.deinit();
        const leaked = gpa.deinit();
        if (leaked) expect(false) catch @panic("TEST FAIL");
    }

    const allocator = arena.allocator();
    var root = std.StringHashMap(*HashMap).init(allocator);
    defer root.deinit();
    var hashMap = &root;
    const keys = [_][]const u8{ "a", "b", "c" };
    const values: [3]u8 = .{ 1, 2, 3 };
  
    // 移除inline，使用堆分配节点
    for (keys) |key, i| {
        print("put key {s}:{}\n", .{ key, values[i] });
        var newNode = try HashMap.init(allocator, values[i]);
        try hashMap.put(key, newNode);
        showTree(&root, keys);
        hashMap = &newNode.children;
    }
   
    showTree(&root, keys);
}

修正后输出 #

无论是带inline还是移除inline，都会输出预期的正确结果：

Test [1/1] test "HashMap"... 
put key a:1
get key a
we got a value for a:1
get key b
no value for b
put key b:2
get key a
we got a value for a:1
get key b
we got a value for b:2
get key c
no value for c
put key c:3
get key a
we got a value for a:1
get key b
we got a value for b:2
get key c
we got a value for c:3
get key a
we got a value for a:1
get key b
we got a value for b:2
get key c
we got a value for c:3
All 1 tests passed.

关键修改点 #

1. 将newHashMap改为HashMap.init方法，使用allocator.create在堆上分配节点，返回*HashMap指针，确保节点内存不会被循环覆盖。
2. 添加deinit方法，递归清理Trie节点和HashMap资源，避免内存泄漏。
3. 修正根HashMap的初始化方式，确保其生命周期被正确管理。

内容的提问来源于stack exchange，提问作者seriousme