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});
}
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;
}
}
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});
}
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;
}
}
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);
}
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
点我分享笔记