Zig 数组和切片

在 Zig 编程语言中，数组和切片（slice）是用于存储和操作一组相同类型数据的基本结构。

• 数组：用于存储固定大小的一组相同类型的数据，定义时指定大小，存储在栈上。
• 切片：用于引用数组或其他连续内存区域的一部分，大小可动态调整，更灵活，通常引用堆内存。

数组（Array）：

• 数组是一种固定长度的序列，它在编译时大小就已经确定。
• 数组的类型是[T]，其中T是数组中元素的类型。
• 数组的内存是连续的，这使得它们在性能上很有优势，尤其是在处理大量数据时。

切片（Slice）：

• 切片是一种动态长度的序列，它允许在运行时改变大小。
• 切片的类型是[]T，其中T是切片中元素的类型。
• 切片实际上是对数组的引用，它包含指向数组的指针和切片的长度。
• 切片可以更灵活地处理数据，因为它们可以轻松地在不同的数组之间共享和传递。

数组

数组是固定大小的，存储在栈上，元素类型必须相同。

可以使用 [] 语法来定义数组，并指定数组的大小。

数组的类型定义为 [T; N]，其中 T 是数组元素的类型，N 是数组的长度。

数组的元素可以通过索引访问，索引从 0 开始。

语法格式

const arrayName: [size]ElementType = [size]ElementType{element1, element2, ...};

参数说明：

• arrayName：数组的名称。
• size：数组的大小（元素数量），是一个编译时常量。
• ElementType：数组中元素的类型。
• element1, element2, ...：数组中的元素。

数组是一个固定大小的连续内存块，它在编译时大小就已经确定：

var myArray: [10]u8 = [10]u8{0} ** 10; // 定义并初始化一个大小为 10 的 u8 类型数组

实例

const std = @import("std");

pub fn main() void {
    // 定义一个包含 5 个 i32 类型元素的数组
    const arr: [5]i32 = [5]i32{1, 2, 3, 4, 5};

    // 通过索引访问数组元素
    std.debug.print("First element: {}\n", .{arr[0]});
    std.debug.print("Third element: {}\n", .{arr[2]});

    // 数组的大小是固定的
    const size: usize = arr.len;
    std.debug.print("Array size: {}\n", .{size});
}

编译输出结果为：

First element: 1
Third element: 3
Array size: 5

遍历数组

可以使用 for 循环来遍历数组的元素。

实例

const std = @import("std");

pub fn main() void {
    const arr: [5]i32 = [5]i32{ 1, 2, 3, 4, 5 };

    var index: usize = 0;

    // 遍历数组
    for (arr) |item| {
        std.debug.print("Index: {}, Item: {}\n", .{ index, item });
        index += 1;
    }
}

编译输出结果为：

Index: 0, Item: 1
Index: 1, Item: 2
Index: 2, Item: 3
Index: 3, Item: 4
Index: 4, Item: 5

切片（Slice）

切片是对数组或其他连续内存区域的一部分的引用。

切片可以动态调整大小，并且比数组更灵活，但其元素存储在堆上。

定义和初始化

切片是对数组或其他连续内存区域的一部分的引用。

切片是动态的，可以改变其大小，通常用于表示数组的一部分或动态分配的内存块。

语法格式

const sliceName: []ElementType = array[start..end];

参数说明：

• sliceName：切片的名称。
• ElementType：切片中元素的类型。
• array[start..end]：从 array 中提取一个子切片，start 和 end 是索引。

切片可以通过数组的子集来创建，也可以通过指针和长度来创建：

var myArray: [10]u8 = ...; // 假设已经初始化
var mySlice = myArray[2..7]; // 创建一个切片，包含索引2到6的元素

// 或者使用指针和长度
var mySlicePtr = myArray[2..]; // 创建一个切片，从索引2开始到数组末尾

切片提供了一些内置的方法来操作切片，例如：

• len：获取切片的长度。
• ptr：获取切片的指针。
• capacity：获取切片的容量，即它能够引用的数组部分的最大长度。

实例

const std = @import("std");

pub fn main() void {
    var arr: [5]i32 = [5]i32{ 1, 2, 3, 4, 5 };

    // 从数组创建切片
    const slice: []i32 = arr[1..4];

    // 通过索引访问切片元素
    std.debug.print("First element of slice: {}\n", .{slice[0]});
    std.debug.print("Second element of slice: {}\n", .{slice[1]});

    // 切片的长度
    const length: usize = slice.len;
    std.debug.print("Slice length: {}\n", .{length});
}

编译输出结果为：

First element of slice: 2
Second element of slice: 3
Slice length: 3

遍历切片

与数组类似，可以使用 for 循环遍历切片。

实例

const std = @import("std");

pub fn main() void {
    var arr: [5]i32 = [5]i32{ 1, 2, 3, 4, 5 };
    const slice: []i32 = arr[1..4];
    var index: usize = 1;

    // 遍历切片
    for (slice) |item| {
        std.debug.print("Index: {}, Item: {}\n", .{ index, item });
        index += 1;
    }
}

编译输出结果为：

Index: 1, Item: 2
Index: 2, Item: 3
Index: 3, Item: 4

数组与切片的区别

• 大小：数组的大小是固定的，定义时即确定；切片的大小可以动态调整。
• 存储位置：数组通常存储在栈上，而切片引用的内存可以在堆上。
• 灵活性：切片更灵活，可以引用数组的一部分或动态分配的内存。

以下实例中，printArray 函数接受一个固定大小的数组作为参数，而 printSlice 函数接受一个切片作为参数。通过这些函数，可以看到数组和切片在传递和使用上的差异。

实例

const std = @import("std");

fn printArray(arr: [5]i32) void {
    for (arr) |item| {
        std.debug.print("Array item: {}\n", .{item});
    }
}

fn printSlice(slice: []const i32) void {
    for (slice) |item| {
        std.debug.print("Slice item: {}\n", .{item});
    }
}

pub fn main() void {
    const arr: [5]i32 = [5]i32{ 1, 2, 3, 4, 5 };
    const slice: []const i32 = arr[1..4];

    printArray(arr);
    printSlice(slice);
}

编译输出结果为：

Array item: 1
Array item: 2
Array item: 3
Array item: 4
Array item: 5
Slice item: 2
Slice item: 3
Slice item: 4