Compiler Explorer

Source code

const std = @import("std");

const Blob = enum { A, B, C };

const HM = std.StringHashMap(Blob);

fn wrong(alloc: anytype) !void {
    var hm = HM.init(alloc);
    defer hm.deinit();
    var key: [1]u8 = .{'A'};
    try hm.put(&key, .A);
    key[0] = 'B';
    try hm.put(&key, .B);
    key[0] = 'C';
    try hm.put(&key, .C);
    var keyIt = hm.keyIterator();

// note that they have all the same address here:
    while (keyIt.next()) |k| {
        std.debug.print("Key[{*}]: {s}\n", .{ k.*.ptr, k.* });
    }
    std.debug.print("well... shit\n", .{});
}

fn correct(alloc: anytype) !void {
    var hm = HM.init(alloc);
    defer hm.deinit();

// I'm using static strings here to keep things simple
    // depending on your use case, you'll have to figure out how to manage this:
    //
    // Store copies of the keys (hm.put(try alloc.dupe(key), ...) and free
    // those before de-initing HM?
    //
    // If you know keys will outlive the HM then no copies are necessary
    //
    // You could even use refcounting in particularly complex scenarios, but I'd
    // recommend against reaching for that unless you have to.
    //
    // there's no one correct answer here
    // note that if HM was managing the keys as well, we'd very often incur
    // completely unnecessary copies
    try hm.put("A", .A);
    try hm.put("B", .B);
    try hm.put("C", .C);

var keyIt = hm.keyIterator();
    while (keyIt.next()) |k| {
        std.debug.print("Key[{*}]: {s}\n", .{ k.*.ptr, k.* });
    }
    std.debug.print("now everything looks correct again!\n", .{});
}

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer {
        _ = gpa.deinit();
    }
    const alloc = gpa.allocator();
    try wrong(alloc);
    try correct(alloc);
}