如何在Zig中在堆上创建标准库ArrayHashMap？

常规堆对象创建方式 #

在Zig里，要在堆上自定义结构体对象，通常会写一个create函数分配内存并初始化：

const Something = struct {
   a: std.mem.Allocator,
   b: [1000]u8,
   pub fn create(a: std.mem.Allocator) !*Something {
      var mem = try a.create(Something);
      mem.* = .{
       .a = a,
       .b = undefined
      };
      return mem;
   }
};

问题：堆上创建标准库ArrayHashMap #

但如果要在堆上创建标准库的ArrayHashMap，直接照搬上面的方式会遇到困惑。比如下面的代码存在内存安全隐患：

const StringStringArrayHashMap = std.StringArrayHashMap([]const u8);

fn makeMap(a: std.mem.Allocator) StringStringArrayHashMap {
   return StringStringArrayHashMap.init(a);
}

const WithMap = struct {
   map: StringStringArrayHashMap
};

fn fillMap(a: std.mem.Allocator) !WithMap {
   var map = makeMap(a);
   try map.put("a", "hello");
   try map.put("b", "world");
   return WithMap{ .map = map };
}

fn badMemory(a: std.mem.Allocator) !void {
   const with_map = try fillMap(a);
   _ = with_map;
}

这里的问题是：fillMap中栈上的map结构体被拷贝到WithMap中返回，虽然ArrayHashMap内部的存储是堆分配的，但如果我们需要的是结构体本身在堆上（而非栈上分配再拷贝），就需要另一种实现方式。

解决方案：堆上分配ArrayHashMap结构体 #

要把ArrayHashMap的结构体本身分配在堆上，可以直接用分配器的create方法创建结构体实例，再调用init初始化内部状态：

方案1：直接在函数中处理 #

const std = @import("std");
const StringStringArrayHashMap = std.StringArrayHashMap([]const u8);

const WithMap = struct {
   map: *StringStringArrayHashMap
};

fn fillMap(a: std.mem.Allocator) !WithMap {
   // 堆上分配HashMap结构体内存
   var map_ptr = try a.create(StringStringArrayHashMap);
   // 初始化HashMap的内部状态
   map_ptr.* = StringStringArrayHashMap.init(a);
   // 错误处理：如果put失败，先清理HashMap再释放结构体内存
   errdefer {
       map_ptr.deinit();
       a.destroy(map_ptr);
   }

   try map_ptr.put("a", "hello");
   try map_ptr.put("b", "world");
   return WithMap{ .map = map_ptr };
}

fn goodMemory(a: std.mem.Allocator) !void {
   const with_map = try fillMap(a);
   // 使用完后先释放HashMap内部资源，再销毁堆上的结构体
   defer {
       with_map.map.deinit();
       a.destroy(with_map.map);
   }
   // 这里可以安全使用with_map.map
   _ = with_map;
}

方案2：封装create/destroy函数 #

像自定义结构体那样封装create和destroy函数，方便复用：

const std = @import("std");
const StringStringArrayHashMap = std.StringArrayHashMap([]const u8);

pub fn createHashMap(a: std.mem.Allocator) !*StringStringArrayHashMap {
    var map_ptr = try a.create(StringStringArrayHashMap);
    map_ptr.* = StringStringArrayHashMap.init(a);
    return map_ptr;
}

pub fn destroyHashMap(a: std.mem.Allocator, map_ptr: *StringStringArrayHashMap) void {
    map_ptr.deinit();
    a.destroy(map_ptr);
}

// 使用示例
fn fillMap(a: std.mem.Allocator) !*StringStringArrayHashMap {
    var map_ptr = try createHashMap(a);
    errdefer destroyHashMap(a, map_ptr);
    try map_ptr.put("a", "hello");
    try map_ptr.put("b", "world");
    return map_ptr;
}

关键注意事项 #

• 必须先调用deinit释放ArrayHashMap内部的堆内存，再调用allocator.destroy释放结构体本身的堆内存，顺序不能反
• 始终用errdefer和defer确保资源在错误或函数退出时被正确清理，避免内存泄漏

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