Understanding Array Types in Zig: Fixed, Dynamic and Multi-Dimensional

In Zig, arrays are a collection of elements, all of the same type, stored in contiguous memory locations. Zig offers several ways to work with arrays, ranging from traditional fixed-size arrays to dynamically-sized, growable arrays. Here's an overview of the different types of arrays in Zig and how to use them.

Fixed-Size Arrays

A fixed-size array is an array where the number of elements is specified at compile-time.

const std = @import("std");

pub fn main() void {
    var intArray: [5]i32 = [5]i32{1, 2, 3, 4, 5};
    
    for (intArray) |value, index| {
        std.debug.print("intArray[{}] = {}\n", .{index, value});
    }
}

In this example, intArray is a fixed-size array containing five integers. The length of the array is 5, as specified by [5]i32.

Slice Type

Slices are a commonly used way to handle arrays dynamically. A slice is essentially a runtime representation of a part or whole of an array.

const std = @import("std");

pub fn main() void {
    var intArray: [5]i32 = [5]i32{1, 2, 3, 4, 5};
    var slice: []const i32 = intArray[0..3]; // Slice of the first three elements
    
    for (slice) |value, index| {
        std.debug.print("slice[{}] = {}\n", .{index, value});
    }
}

In the example, slice is a slice of the first three elements of intArray. The notation [0..3] defines a subset of the array.

Dynamic Arrays

Zig's standard library provides a flexible and convenient way to deal with dynamically-sized arrays using std.ArrayList.

const std = @import("std");

pub fn main() void {
    var allocator = std.heap.page_allocator;

    var arrayList = std.ArrayList(i32).init(allocator);
    defer arrayList.deinit();
    
    // Append elements to the array list
    arrayList.append(10) catch unreachable;
    arrayList.append(20) catch unreachable;
    arrayList.append(30) catch unreachable;
    
    // Access elements
    for (arrayList.items) |value, index| {
        std.debug.print("arrayList[{}] = {}\n", .{index, value});
    }
}

In this example, std.ArrayList is used to create a dynamically-sized array that can grow as needed. Allocators are used to manage memory dynamically.

Accessing Array Elements

To access elements of an array, you can use the bracket [] operator with the index:

pub fn main() void {
    var intArray: [5]i32 = [5]i32{1, 2, 3, 4, 5};
    
    const secondElement = intArray[1]; // Indexing starts from 0
    secondElement = 10; // Update the second element
    
    std.debug.print("Updated second element: {}\n", .{secondElement});
}

Multi-Dimensional Arrays

Zig also supports multi-dimensional arrays:

const std = @import("std");

pub fn main() void {
    var matrix: [2][2]i32 = [
        [2]i32{1, 2},
        [2]i32{3, 4},
    ];
    
    std.debug.print("matrix[0][1] = {}\n", .{matrix[0][1]});
}

In this example, matrix is a 2x2 array. You can access elements using multiple indices.

Conclusion

Arrays in Zig are versatile and come in various forms to suit different needs. Whether you're working with fixed-size arrays, slices, dynamic arrays, or multi-dimensional arrays, Zig provides efficient and flexible ways to handle collections of data. The standard library enhances these capabilities further, particularly with dynamic memory management.