数组类型标注 [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>(保留长度信息)。