Rust如何可变迭代切片返回&mut[1,4,7]等不相交可变列切片

注意事项 #

Rust 中的标准可变切片&mut [T]要求指向连续内存区域，你示例中提到的&mut [1,4,7]这类跨块元素集合在原始切片中内存不连续，因此无法直接作为标准切片返回，这是语言底层的限制，和借用检查规则无关。

如果你的需求是每次迭代可以依次访问所有分块第n个元素的可变引用，不需要连续内存的切片结构，以下是完全符合要求的实现方案：

• 无 unsafe 代码
• 全程无内存分配，无 Vec 使用
• 借用检查可自动识别返回引用不相交

编译期固定分块大小实现（零分配、完全安全） #

如果分块大小可以在编译期确定，可采用以下实现，编译器会通过数组类型自动校验引用不相交：

use std::slice::ArrayChunksMut;

/// 编译期固定分块大小的列迭代器
pub struct ConstColIterMut<'a, T, const CHUNK_SIZE: usize> {
    chunks: ArrayChunksMut<'a, T, CHUNK_SIZE>,
    current_col: usize,
}

impl<'a, T, const CHUNK_SIZE: usize> ConstColIterMut<'a, T, CHUNK_SIZE> {
    /// 构造迭代器，自动截断不足一个分块的尾部元素
    pub fn new(slice: &'a mut [T]) -> Self {
        assert!(CHUNK_SIZE > 0, "chunk size must be greater than 0");
        let valid_len = slice.len() / CHUNK_SIZE * CHUNK_SIZE;
        Self {
            chunks: slice[..valid_len].array_chunks_mut::<CHUNK_SIZE>(),
            current_col: 0,
        }
    }
}

impl<'a, T, const CHUNK_SIZE: usize> Iterator for ConstColIterMut<'a, T, CHUNK_SIZE> {
    /// 每次返回当前列所有元素的可变引用迭代器，无任何内存分配
    type Item = impl Iterator<Item = &'a mut T> + 'a;

    fn next(&mut self) -> Option<Self::Item> {
        if self.current_col >= CHUNK_SIZE {
            return None;
        }
        let col = self.current_col;
        self.current_col += 1;
        Some(self.chunks.by_ref().map(move |chunk| &mut chunk[col]))
    }
}

使用示例 #

fn main() {
    let mut arr = [1,2,3,4,5,6,7,8,9];
    // 分块大小3为编译期常量
    let mut col_iter = ConstColIterMut::<'_, _, 3>::new(&mut arr);

    // 迭代第一列元素：1、4、7，无需分配直接使用迭代器
    let mut col0 = col_iter.next().unwrap();
    assert_eq!(col0.next(), Some(&mut 1));
    assert_eq!(col0.next(), Some(&mut 4));
    assert_eq!(col0.next(), Some(&mut 7));
    assert_eq!(col0.next(), None);

    // 迭代第二列元素：2、5、8
    let mut col1 = col_iter.next().unwrap();
    assert_eq!(col1.next(), Some(&mut 2));
    assert_eq!(col1.next(), Some(&mut 5));
    assert_eq!(col1.next(), Some(&mut 8));
    assert_eq!(col1.next(), None);

    // 迭代第三列元素：3、6、9
    let mut col2 = col_iter.next().unwrap();
    assert_eq!(col2.next(), Some(&mut 3));
    assert_eq!(col2.next(), Some(&mut 6));
    assert_eq!(col2.next(), Some(&mut 9));
    assert_eq!(col2.next(), None);

    assert!(col_iter.next().is_none());
}

如果需要支持运行期动态分块大小，仅需要添加一行安全的unsafe代码手动告知编译器引用不相交，逻辑和上述实现基本一致。

内容的提问来源于stack exchange，提问作者Rafaelo