数组类型标注 [T; N]
数组类型的语法
Rust 中数组的类型写作 [T; N],其中 T 是元素类型,N 是数组长度。长度 N 是类型的一部分,这意味着 [i32; 3] 和 [i32; 5] 是两个完全不同的类型,不能互相赋值或传参。
rust
fn main() {
// 显式标注数组类型
let a: [i32; 5] = [1, 2, 3, 4, 5];
let b: [f64; 3] = [1.0, 2.0, 3.0];
let c: [bool; 2] = [true, false];
let d: [&str; 4] = ["春", "夏", "秋", "冬"];
// 长度是类型的一部分
// let e: [i32; 3] = [1, 2, 3, 4]; // 编译错误:expected 3, found 4
println!("{:?}, {:?}, {:?}, {:?}", a, b, c, d);
}长度是类型的一部分
这一点对理解 Rust 的数组非常关键。不同长度的数组是不同类型,不能混用。
rust
fn main() {
let arr3: [i32; 3] = [1, 2, 3];
let arr5: [i32; 5] = [1, 2, 3, 4, 5];
// 这两个数组类型不同,不能赋值
// let x: [i32; 3] = arr5; // 编译错误
// 函数参数也是如此
fn print_three(arr: [i32; 3]) {
println!("{:?}", arr);
}
print_three(arr3); // 正确
// print_three(arr5); // 编译错误:expected [i32; 3], found [i32; 5]
// 如果想写能接受不同长度数组的函数,用切片 &[T]
fn print_any(arr: &[i32]) {
println!("{:?}", arr);
}
print_any(&arr3); // 正确
print_any(&arr5); // 也正确
}长度必须是编译期常量
N 不能是运行时计算的值,必须在编译期就能确定。
rust
// const 常量可以用作数组长度
const SIZE: usize = 10;
// const fn 的返回值也可以
const fn double(n: usize) -> usize {
n * 2
}
fn main() {
// 字面量作为长度
let a: [i32; 5] = [0; 5];
// const 常量作为长度
let b: [i32; SIZE] = [0; SIZE];
// const fn 返回值作为长度
let c: [i32; double(3)] = [0; double(3)]; // [i32; 6]
// 运行时变量不能作为长度
// let n = 5;
// let d: [i32; n] = [0; n]; // 编译错误:attempt to use a non-constant value
println!("a: {:?}", a);
println!("b: {:?}", b);
println!("c: {:?}", c);
}泛型常量参数
从 Rust 1.51 开始,可以用 const 泛型参数编写适用于任意长度数组的函数。
rust
// N 是一个泛型常量参数,表示数组的长度
// 这个函数可以接受任意长度的 i32 数组
fn sum_array<const N: usize>(arr: [i32; N]) -> i32 {
let mut total = 0;
for &val in &arr {
total += val;
}
total
}
// 打印任意长度数组的信息
fn array_info<T: std::fmt::Debug, const N: usize>(arr: &[T; N]) {
println!("长度:{},内容:{:?}", N, arr);
}
fn main() {
let a = [1, 2, 3];
let b = [10, 20, 30, 40, 50];
// 同一个函数可以处理不同长度的数组
println!("sum([1,2,3]) = {}", sum_array(a));
println!("sum([10,20,30,40,50]) = {}", sum_array(b));
array_info(&a);
array_info(&b);
}多维数组
多维数组用嵌套的类型标注表示。
rust
fn main() {
// 二维数组:3 行 4 列
// 类型是 [[i32; 4]; 3]:3 个元素,每个元素是 [i32; 4]
let matrix: [[i32; 4]; 3] = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
];
// 访问元素:matrix[行][列]
println!("第 2 行第 3 列:{}", matrix[1][2]); // 7
// 遍历二维数组
for row in &matrix {
for &val in row {
print!("{:3} ", val);
}
println!();
}
// 初始化全零的二维数组
let zeros: [[f64; 3]; 3] = [[0.0; 3]; 3];
println!("{:?}", zeros);
}基本示例
用常量泛型实现一个固定大小的环形缓冲区:
rust
// 固定大小的栈,N 是编译期常量
struct FixedStack<const N: usize> {
data: [i32; N], // 存储空间
top: usize, // 栈顶位置
}
impl<const N: usize> FixedStack<N> {
// 创建空栈
fn new() -> Self {
FixedStack {
data: [0; N],
top: 0,
}
}
// 入栈
fn push(&mut self, value: i32) -> bool {
if self.top >= N {
return false; // 栈满
}
self.data[self.top] = value;
self.top += 1;
true
}
// 出栈
fn pop(&mut self) -> Option<i32> {
if self.top == 0 {
return None; // 栈空
}
self.top -= 1;
Some(self.data[self.top])
}
// 查看栈顶
fn peek(&self) -> Option<i32> {
if self.top == 0 {
None
} else {
Some(self.data[self.top - 1])
}
}
// 当前元素个数
fn len(&self) -> usize {
self.top
}
}
fn main() {
// 创建容量为 5 的栈
let mut stack = FixedStack::<5>::new();
stack.push(10);
stack.push(20);
stack.push(30);
println!("栈顶:{:?}", stack.peek()); // Some(30)
println!("元素个数:{}", stack.len()); // 3
while let Some(val) = stack.pop() {
println!("弹出:{}", val);
}
}常见问题
问题一:为什么数组长度要是类型的一部分?
因为编译器需要在编译期知道数组占多大内存(N * size_of::<T>() 字节),才能在栈上为它分配空间。如果长度不是类型的一部分,编译器就无法确定内存布局。
问题二:数组类型标注可以省略吗?
大多数情况下可以省略,编译器能从初始值推断。但在用 [value; N] 初始化且 value 的类型有歧义时(比如数字字面量),可能需要标注。
rust
fn main() {
let a = [1, 2, 3]; // 推断为 [i32; 3]
let b = [0u8; 100]; // 通过后缀指定为 [u8; 100]
let c: [f32; 4] = [0.0; 4]; // 通过标注指定为 [f32; 4]
println!("{:?}, {:?}, {:?}", a, b, c);
}问题三:const 泛型参数有什么限制?
目前 const 泛型参数只能是整数类型(usize、i32、bool 等),不能是浮点数或复杂类型。usize 是最常用的,因为数组长度就是 usize 类型。
适用场景
- 固定大小的缓冲区:网络数据包、音频采样块等
- 矩阵和数学向量:
[f64; 3]表示三维向量 - 查找表:
[u8; 256]用 ASCII 值做索引的查找表 - 嵌入式开发:编译期确定大小,避免堆分配
- 常量泛型结构体:用
const N: usize参数化数据结构的大小
注意事项
[T; N]中的N必须是编译期常量- 不同长度的数组是不同类型,
[i32; 3]不能赋值给[i32; 5] - 写能接受不同长度数组的函数时,用切片
&[T]或 const 泛型参数 - 大数组(几百 KB 以上)放在栈上可能导致栈溢出,考虑用
Vec或Box<[T]> - 数组类型标注中不能用运行时变量作为长度
- const 泛型参数目前只支持整数类型
总结
Rust 的数组类型 [T; N] 包含元素类型 T 和长度 N 两个部分,长度是类型的一部分,不同长度的数组是不同类型。N 必须是编译期常量,不能是运行时变量。这个设计让编译器能在编译期确定数组的内存大小,实现栈上分配。如果需要写适用于不同长度数组的通用代码,可以用切片引用 &[T](丢弃长度信息)或 const 泛型参数 <const N: usize>(保留长度信息)。