Zig语言中如何类型安全地在函数中遍历多维数组

问题背景 #

我已成功实现一维数组的遍历函数：

const std = @import("std");

pub fn loopArray(arr: []u8) void {
    for (arr, 0..) |elem, i| {
        std.debug.print("array at {d} = {d}\n", .{ i, elem });
    }
}

var foo: [4]u8 = .{ 4, 3, 2, 8 };

pub fn main() void {
    loopArray(&foo);
}

但扩展到多维数组时，编写的函数调用报错：

pub fn loopArray2(arr: [][]u8) void {
    for (arr, 0..) |row, j| {
        for (row, 0..) |elem, i| {
            std.debug.print("array at {d},{d} = {d}\n", .{ j, i, elem });
        }
    }
}
var bar: [2][4]u8 = .{ .{ 4, 3, 2, 8 }, .{ 4, 3, 2, 8 } };

pub fn main() void {
    loopArray2(&bar); // 此处报错
}

错误信息：

arrayLoop.zig:21:16: error: expected type '[][]u8', found '*[2][4]u8'
    loopArray2(&bar);

使用anytype参数可实现功能，但希望函数有更严格的类型约束，如何正确实现类型安全的多维数组遍历函数？

错误原因 #

[][]u8是切片的切片（动态长度的数组切片），而&bar是指向固定大小二维数组[2][4]u8的指针，两者类型不兼容。Zig中固定大小数组和切片是完全不同的类型：多维固定数组内存连续布局，切片的切片则是分散的指针数组，无法直接转换。

类型安全的解决方案 #

1. 针对固定维度的二维数组 #

如果仅需处理特定维度的二维数组，直接指定数组指针类型即可：

pub fn loopFixed2D(arr: *[2][4]u8) void {
    for (arr.*, 0..) |row, j| {
        for (row, 0..) |elem, i| {
            std.debug.print("array at {d},{d} = {d}\n", .{ j, i, elem });
        }
    }
}

// 调用示例
loopFixed2D(&bar);

2. 泛型函数支持任意固定维度的二维数组 #

通过Zig泛型参数约束数组类型，适配任意大小的固定二维数组：

pub fn loopGeneric2D(comptime N: usize, comptime M: usize, arr: *[N][M]u8) void {
    for (arr.*, 0..) |row, j| {
        for (row, 0..) |elem, i| {
            std.debug.print("array at {d},{d} = {d}\n", .{ j, i, elem });
        }
    }
}

// 调用时编译器自动推导N和M
loopGeneric2D(&bar);

3. 支持二维切片（[][]u8）的场景 #

若需处理动态二维切片，可直接接收切片参数，或提前将固定数组转换为切片的切片：

// 处理切片的切片的函数
pub fn loopSlice2D(arr: [][]u8) void {
    for (arr, 0..) |row, j| {
        for (row, 0..) |elem, i| {
            std.debug.print("array at {d},{d} = {d}\n", .{ j, i, elem });
        }
    }
}

// 调用示例：将固定数组转换为切片的切片
pub fn main() void {
    var slice_arr: [][]u8 = &[_][]u8{ &bar[0], &bar[1] };
    loopSlice2D(slice_arr);
}

4. 带编译期检查的通用约束 #

如果想支持所有二维可遍历类型（固定数组、切片等），同时保留类型约束，可通过编译期类型检查实现：

pub fn loopConstrained2D(arr: anytype) void {
    // 编译时验证输入类型符合二维u8结构要求
    comptime {
        const T = @TypeOf(arr);
        // 处理指针类型（如*[N][M]u8）
        const ElemType = if (@typeInfo(T) == .Pointer) @typeInfo(T).Pointer.child else T;
        
        if (@typeInfo(ElemType) != .Array and @typeInfo(ElemType) != .Slice) {
            @compileError("Expected 2D array or slice, got " ++ @typeName(T));
        }

        const RowType = if (@typeInfo(ElemType) == .Array) ElemType.child else @typeInfo(ElemType).Slice.child;
        if (RowType != u8) {
            @compileError("Expected element type u8, got " ++ @typeName(RowType));
        }
    }

    for (arr, 0..) |row, j| {
        for (row, 0..) |elem, i| {
            std.debug.print("array at {d},{d} = {d}\n", .{ j, i, elem });
        }
    }
}

// 支持多种调用方式：&bar、bar、[][]u8切片等
loopConstrained2D(&bar);

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