能否实现返回借用项的迭代器？SpaceCursor返回&[i32;2]的疑问

要把迭代器的Item类型改为&[i32; D]确实可行，但不能直接修改原Iterator实现的关联类型——因为Rust的Iterator trait要求返回的引用生命周期必须和迭代器实例绑定，而原SpaceCursor结构体没有携带生命周期参数，无法直接返回指向自身内部数据的引用。

解决方法是拆分出一个借用型迭代器结构体，让它持有对SpaceCursor的可变引用，从而将引用的生命周期绑定到原SpaceCursor实例的生命周期上。以下是修改后的完整代码：

struct SpaceCursor<const D: usize> {
    cursor: [i32; D],
    boundary: [usize; D],
}

impl<const D: usize> SpaceCursor<D> {
    pub fn new(boundary: &[usize]) -> Self {
        let mut result = SpaceCursor {
            cursor: [0; D],
            boundary: boundary.try_into().expect("Bad boundary length"),
        };
        if D >= 1 {
            result.cursor[0] = -1;
        }
        result
    }

    // 返回一个绑定到当前SpaceCursor实例的借用迭代器
    pub fn iter(&mut self) -> SpaceCursorIter<'_, D> {
        SpaceCursorIter { inner: self }
    }
}

// 借用型迭代器，持有对SpaceCursor的可变引用，生命周期'α绑定到原实例
struct SpaceCursorIter<'a, const D: usize> {
    inner: &'a mut SpaceCursor<D>,
}

impl<'a, const D: usize> Iterator for SpaceCursorIter<'a, D> {
    // Item是绑定到原SpaceCursor实例生命周期的不可变数组引用
    type Item = &'a [i32; D];

    fn next(&mut self) -> Option<Self::Item> {
        let cursor = &mut self.inner.cursor;
        let boundary = &self.inner.boundary;
        let mut index = 0;

        while index < D {
            cursor[index] += 1;
            if cursor[index] < boundary[index] as i32 {
                break;
            }
            index += 1;
        }

        if index == D {
            None
        } else {
            // 复位前面的维度
            for i in 0..index {
                cursor[i] = 0;
            }
            // 将可变引用转为不可变引用返回，避免外部修改迭代器状态
            Some(cursor)
        }
    }
}

使用方式 #

现在你需要通过iter()方法获取迭代器，而不是直接遍历SpaceCursor实例：

fn main() {
    let mut cursor = SpaceCursor::<2>::new(&[2, 2]);
    for pos in cursor.iter() {
        println!("{pos:?}");
        // 输出依次是 [0, 0]、[1, 0]、[0, 1]、[1, 1]
    }
}

关键说明 #

1. 生命周期绑定：SpaceCursorIter的生命周期'a和原SpaceCursor实例绑定，保证返回的&[i32; D]引用在原实例存活期间始终有效。
2. 避免复制：每次next()返回的是对内部cursor数组的引用，不再复制整个数组，适合维度D较大的场景。
3. 不可变引用：返回不可变引用是为了防止外部修改迭代器的内部状态，避免破坏遍历逻辑。如果确实需要可变引用，需谨慎处理（可能导致迭代顺序错乱）。

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