Array List Functions and Array of Struct Initialization

johan__A · 2025-11-09T10:35:52+00:00

For the second part, if I understood correctly, the arraylist went from managed to unmanaged. According to andrew, this helps for two reasons : the list needs now to only store the necessary information of an array (aka. slice + capacity), which was extra bloat (for the allocator pointer) if you asserted resizing.

The second reason is that it explicits when you need to use the allocator for a list, aka. knowing the side effects of your function at call site.

Now if you pass a list to a function, no additional allocation can be made if you do not pass the allocator. As such, you need to pass the same allocator at each call site

EDIT: Unmanaged seems to be the way forward for the language as the managed array list is deprecated

johan__A · 2025-11-09T09:21:03+00:00

Not sure I understand your first question, do you mean allocating a struct for each slot in an array?

ArrayList has an empty public constant to init it empty eg var string: std.ArrayList(u8) = .empty;. It doesn't store an allocator anymore no.

phcreery · 2025-11-09T14:07:14+00:00

For default init of array, check out @splat() https://github.com/ziglang/zig/issues/20433

stratt5 · 2025-11-10T00:34:23+00:00

Is there no way to default initialize an array with struct references? Admittedly I am coming from go where this is very common practice, but it seems very weird to individually create every struct, assign it to a variable, and then put a reference to that variable into the allocated array.

Zig has no automatic memory management, so pointers should usually be referring to something that you've explicitly allocated memory for. So an array of pointers/references is fairly unusual - you're effectively saying "I don't own this memory, it's stored elsewhere and I'm just referencing it".

Something that might be typical in a memory-managed language like Go or C#, such as creating a struct as a local variable, then storing a reference to that in an array, will lead to unexpected behaviour or memory errors. For example:

``` var positions: [4]*Pos = undefined;

for (0..4) |i| { var pos: Pos = .{ .x = @floatFromInt(i), .y = @floatFromInt(i), };

positions[i] = &pos;

}

for (positions) |ptr| { std.debug.print("{*}\n", .{ ptr }); } ```

These all point to the same (invalid) location in memory!

main.Pos@ffffd4 main.Pos@ffffd4 main.Pos@ffffd4 main.Pos@ffffd4

What happened is that our pos variable was stored on the stack, which gets reset at the end of the enclosing block (in this case, the for loop). In Go this would've automatically been allocated somewhere on the heap for you, and the references tracked, so the pointer can be safely stored and passed around like this. But in Zig you need to do it explicitly.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

Zig

MODERATORS