Help understanding ArrayList.toOwnedSlice

[pastel gorge]

I have a function call where i create an ArrayList(u8) but I don't defer list.deinit() because I want to return an owned ArrayList to the caller function. The reason, acc. to my understanding is if I do return a slice i.e. []const u8 and call defer list.deinit() then my slice will point to invalid or freed memory which is rarely what anyone wants.

So searching around I found toOwnedSlice which seems like it does what I want that is return an []u8 but it clears or empties the arraylist? I don't understand this comment, does calling this method free the array list? If so then what is the returned slice a view of?

[reef blaze]

toOwnedSlice "moves" the memory out of the arraylist, such that a deinit() on the list no longer does anything to the toOwnedSlice result

to get a "view" while still having the arraylist own the allocation, use array_list.items

[pastel gorge]

I understand that the memory of the arraylist no longer holds the backing data, but the slice returned, what does it point to? Some arbitrary memory address outside the array list?

[silent lagoon]

the array-lists owns some range of memory got from its allocator - the toOwnedSlice method returns a range of memory containing the array-list's items, also from that same allocator, the method also resets the array-list to its empty state, making deinitialisation unnecessary

the returned slice is owned by the caller, that is, you have to free it yourself, lest a memory leak will occur

[pastel gorge]

Ah I see. So in the case where we don't turn the ArrayList into an owned slice, the arraylist itself is responsible for calling free on the slice

the free syntax changes from list.deinit() to allocator.free(owned_slice)

Would this code sample be considered correct?

    try file_name.appendSlice(suffix);

    const result = try file_name.toOwnedSlice();
    defer allocator.free(result);

    return std.fs.path.join(allocator, &.{ base_dir, result });

since I am creating a separate path allocation

[silent lagoon]

yes - you usually use toOwnedSlice when you've built yourself a sequence of items, and know you no longer need to resize it: an array-list stores one extra usize and over-allocates for efficient append calls. converting the list into an owned slice saves on memory both on the stack and the heap