数组切片 &[T] ​

什么是切片 ​

切片(Slice)是对一段连续内存中元素序列的引用。它的类型写作 &[T],其中 T 是元素类型。切片本身不拥有数据,它只是"借用"了某个数组、Vec 或其他连续内存区域中的一部分(或全部)元素。

切片在内存中是一个"胖指针"(fat pointer),由两部分组成:一个指向数据起始位置的指针,加上一个表示元素个数的长度。所以 &[T] 占 16 字节(64 位系统上,指针 8 字节 + 长度 8 字节)。

rust
fn main() {
    let arr = [1, 2, 3, 4, 5];

    // 从数组创建切片(引用整个数组)
    let slice: &[i32] = &arr;
    println!("切片:{:?}", slice);        // [1, 2, 3, 4, 5]
    println!("切片长度:{}", slice.len()); // 5

    // 引用数组的一部分
    let partial: &[i32] = &arr[1..4];
    println!("部分切片:{:?}", partial);   // [2, 3, 4]

    // 切片的内存大小(胖指针)
    println!("&[i32] 大小:{} 字节", std::mem::size_of::<&[i32]>());  // 16
    println!("[i32; 5] 大小:{} 字节", std::mem::size_of::<[i32; 5]>());  // 20
}

切片的来源 ​

切片可以从多种数据源创建。

rust
fn main() {
    // 从数组创建切片
    let array = [10, 20, 30, 40, 50];
    let s1: &[i32] = &array;         // 整个数组
    let s2: &[i32] = &array[1..3];   // 部分

    // 从 Vec 创建切片
    let vec = vec![1, 2, 3, 4, 5];
    let s3: &[i32] = &vec;           // 整个 Vec
    let s4: &[i32] = &vec[2..];      // 从索引 2 到末尾

    // 字符串切片(&str 就是 &[u8] 的特化版本)
    let text = "hello";
    let bytes: &[u8] = text.as_bytes();

    println!("{:?}, {:?}, {:?}, {:?}, {:?}", s1, s2, s3, s4, bytes);
}

切片作为函数参数 ​

切片最大的价值是让函数能接受任意长度的数据。不管你传的是 [i32; 3]、[i32; 100] 还是 Vec<i32>,都可以统一用 &[i32] 接收。

rust
// 这个函数可以接受任意长度的 i32 序列
fn sum(data: &[i32]) -> i32 {
    let mut total = 0;
    for &val in data {
        total += val;
    }
    total
}

// 查找最大值
fn find_max(data: &[i32]) -> Option<i32> {
    if data.is_empty() {
        return None;
    }
    let mut max = data[0];
    for &val in &data[1..] {
        if val > max {
            max = val;
        }
    }
    Some(max)
}

fn main() {
    // 传数组
    let arr = [1, 2, 3];
    println!("数组的和:{}", sum(&arr));

    // 传不同长度的数组
    let arr2 = [10, 20, 30, 40, 50];
    println!("数组的和:{}", sum(&arr2));

    // 传 Vec
    let vec = vec![100, 200, 300];
    println!("Vec 的和:{}", sum(&vec));

    // 传部分切片
    println!("部分的和:{}", sum(&arr2[1..4]));  // 20+30+40=90

    // 查找最大值
    println!("最大值:{:?}", find_max(&arr2));  // Some(50)
    println!("空的最大值:{:?}", find_max(&[])); // None
}

可变切片 &mut [T] ​

可变切片允许你通过切片修改原始数据。

rust
fn main() {
    let mut numbers = [5, 3, 8, 1, 9, 2, 7];

    // 创建可变切片
    let slice: &mut [i32] = &mut numbers;

    // 通过切片修改原始数据
    slice[0] = 100;
    println!("修改后:{:?}", numbers);  // [100, 3, 8, 1, 9, 2, 7]

    // 切片自带 sort 方法
    let slice = &mut numbers[..];
    slice.sort();
    println!("排序后:{:?}", numbers);  // [1, 2, 3, 7, 8, 9, 100]

    // 反转
    numbers.reverse();
    println!("反转后:{:?}", numbers);  // [100, 9, 8, 7, 3, 2, 1]
}

// 函数接受可变切片参数
fn double_values(data: &mut [i32]) {
    for val in data.iter_mut() {
        *val *= 2;
    }
}

切片的常用方法 ​

rust
fn main() {
    let data = [10, 20, 30, 40, 50, 60, 70];
    let slice = &data[..];

    // 长度和是否为空
    println!("长度:{}", slice.len());          // 7
    println!("为空:{}", slice.is_empty());     // false

    // 获取第一个和最后一个
    println!("第一个:{:?}", slice.first());    // Some(&10)
    println!("最后一个:{:?}", slice.last());   // Some(&70)

    // 安全地获取指定位置
    println!("索引 3:{:?}", slice.get(3));     // Some(&40)
    println!("索引 99:{:?}", slice.get(99));   // None

    // 是否包含某个值
    println!("包含 30:{}", slice.contains(&30));  // true
    println!("包含 99:{}", slice.contains(&99));  // false

    // 分割切片
    let (left, right) = slice.split_at(3);
    println!("左半:{:?}", left);    // [10, 20, 30]
    println!("右半:{:?}", right);   // [40, 50, 60, 70]

    // 窗口迭代
    println!("长度为 3 的窗口:");
    for window in slice.windows(3) {
        println!("  {:?}", window);
    }

    // 分块迭代
    println!("每 3 个一组:");
    for chunk in slice.chunks(3) {
        println!("  {:?}", chunk);
    }

    // 二分查找(数据必须已排序)
    let sorted = [1, 3, 5, 7, 9, 11];
    println!("查找 7:{:?}", sorted.binary_search(&7));   // Ok(3)
    println!("查找 6:{:?}", sorted.binary_search(&6));   // Err(3)
}

基本示例 ​

统计一组数据中连续递增子序列的最大长度:

rust
// 找出切片中最长的连续递增子序列长度
fn longest_increasing_run(data: &[i32]) -> usize {
    if data.len() <= 1 {
        return data.len();
    }

    let mut max_len = 1;
    let mut current_len = 1;

    // 使用 windows(2) 比较相邻元素
    for pair in data.windows(2) {
        if pair[1] > pair[0] {
            current_len += 1;
            if current_len > max_len {
                max_len = current_len;
            }
        } else {
            current_len = 1;
        }
    }

    max_len
}

fn main() {
    let data = [1, 3, 5, 2, 4, 6, 8, 1, 2];
    //          -----  -----------
    //          长度3     长度4

    println!("数据:{:?}", data);
    println!("最长连续递增长度:{}", longest_increasing_run(&data));  // 4

    // 传空切片也没问题
    println!("空数据:{}", longest_increasing_run(&[]));  // 0

    // 传 Vec 也行
    let vec_data = vec![5, 4, 3, 2, 1];
    println!("递减数据:{}", longest_increasing_run(&vec_data));  // 1
}

常见问题 ​

问题一:&[T] 和 [T; N] 有什么区别?

对比项[T; N](数组)&[T](切片)
拥有数据是否(只是引用)
大小N * size_of::<T>()固定 16 字节(胖指针)
长度编译期固定,是类型的一部分运行时确定,不是类型的一部分
存储位置栈引用的数据可以在栈或堆
灵活性只能接受精确匹配长度的数据可以接受任意长度的数据

问题二:切片能独立存在吗?

切片类型 [T](不带 &)是一个"动态大小类型"(DST),不能直接作为变量的类型。你总是通过引用(&[T] 或 &mut [T])来使用它。

问题三:切片会复制数据吗?

不会。切片只是一个指针加长度,它借用原始数据而不复制。创建切片的成本是固定的(创建一个胖指针),和数据长度无关。

问题四:对切片排序会影响原始数据吗?

如果是可变切片(&mut [T]),排序会直接修改原始数据。如果是不可变切片(&[T]),不能调用 sort()。

适用场景 ​

  • 函数参数:接受任意长度的同类型序列
  • 子序列操作:在不复制数据的情况下处理数组或 Vec 的一部分
  • 零成本抽象:切片让你无需知道底层数据是数组还是 Vec
  • 数据分析:用 windows()、chunks() 等方法进行滑动窗口分析
  • 二分查找:对有序切片进行高效查找

注意事项 ​

  • 切片只是借用,不拥有数据。原始数据必须在切片存活期间保持有效
  • &[T] 是不可变切片,&mut [T] 是可变切片
  • 切片的索引越界和数组一样会 panic,安全访问用 .get()
  • 创建切片时的范围(如 &arr[1..4])不能越界
  • 切片可以从切片创建(子切片),不会有性能问题
  • 把数组传给接受 &[T] 的函数时,Rust 会自动做引用转换(deref coercion)

总结 ​

切片 &[T] 是对连续内存中一段元素序列的引用,由指针和长度两部分组成。它不拥有数据,只是借用。切片的核心价值是解耦函数参数和具体的数据容器——一个接受 &[i32] 的函数可以处理数组、Vec 或其他切片的数据,不需要为每种容器写不同的函数。切片提供了丰富的方法(first、last、contains、windows、chunks、binary_search 等)来操作数据。可变切片 &mut [T] 还可以原地修改、排序和反转数据。