Question

我有一个网格：Vec<Vec<Object>>和一对x / y索引。我想找到所有围绕索引的元素。

不幸的是，我不能简单地循环遍历这些元素，因为这最终会借用Vec两次并且借用检查器对我尖叫：

let mut cells = Vec::with_capacity(8);

for cx in xstart..xend {
    for cy in ystart..yend {
        if cx != x || cy != y {
            cells.push(&mut squares[cy as usize][cx as usize]);
        }
    }
}

cells.into_iter()

我将此更改为迭代器链的最佳尝试也失败了：

let xstart = if x == 0 { x } else { x - 1 };
let xlen = if x + 2 > squares[0].len() { x + 1 } else { 3 };
let ystart = if y == 0 { y } else { y - 1 };
let ylen = if y + 2 > squares.len() { y + 1 } else { 3 };

let xrel = x - xstart;
let yrel = y - ystart;

squares.iter().enumerate()
    .skip(ystart).take(ylen).flat_map(|(i, ref row)|
        row.iter().enumerate()
            .skip(xstart).take(xlen).filter(|&(j, &c)| i != yrel || j != xrel))

有谁知道我该怎么做？

Answer 1

就个人而言，当元素的相对位置很重要时，我不确定是否愿意使用迭代器。相反，我会寻求创建一个＆＃34;视图＆＃34;这些元素。

gist can be found here，但这个想法很简单，所以这里是核心结构。

#[derive(Debug)]
struct NeighbourhoodRow<'a, T>
    where T: 'a
{
    pub left    : Option<&'a mut T>,
    pub center  : Option<&'a mut T>,
    pub right   : Option<&'a mut T>,
}

#[derive(Debug)]
struct Neighbourhood<'a, T>
    where T: 'a
{
    pub top     : NeighbourhoodRow<'a, T>,
    pub center  : NeighbourhoodRow<'a, T>,
    pub bottom  : NeighbourhoodRow<'a, T>,
}

为了构建它们，我使用健康剂量的split_at_mut：

fn take_centered_trio<'a, T>(row: &'a mut [T], x: usize) ->
    (Option<&'a mut T>, Option<&'a mut T>, Option<&'a mut T>)
{
    fn extract<'a, T>(row: &'a mut [T], x: usize) -> (Option<&'a mut T>, &'a mut [T]) {
        if x+1 > row.len() {
            (None, row)
        } else {
            let (h, t) = row.split_at_mut(x+1);
            (Some(&mut h[x]), t)
        }
    }

    let (prev, row) = if x > 0 { extract(row, x-1) } else { (None, row) };
    let (elem, row) = extract(row, 0);
    let (next,  _ ) = extract(row, 0);

    (prev, elem, next)
}

其余的只是一些无趣的构造者。

当然，您可以在那些上构建某种迭代器。

Answer 2

你想获得所有周围元素的可变引用，对吗？我认为不可能直接这样做。问题是，Rust无法静态证明您希望对不同的单元格进行可变引用。如果它忽略了这一点，那么，例如，你可能会在索引中犯一个小错误并获得对同一数据的两个可变引用，这是Rust保证要防止的。因此它不允许这样做。

在语言层面，这是由IndexMut特征引起的。您可以看到其唯一方法的self参数生存期如何与结果生存期相关联：

fn index_mut(&'a mut self, index: Idx) -> &'a mut Self::Output;

这意味着如果调用此方法（隐式通过索引操作），那么整个对象将被可变地借用，直到结果引用超出范围。这样可以防止多次调用&mut a[i]。

解决此问题的最简单，最安全的方法是以“双缓冲”方式重构代码 - 您有两个字段实例，并在每个步骤之间相互复制数据。或者，您可以在每个步骤上创建一个临时字段，并在所有计算之后用它替换主要字段，但它可能不如交换两个字段有效。

解决这个问题的另一种方法当然是使用原始*mut指针。这是unsafe，只能作为最后的手段直接使用。但是，您可以使用不安全的方法来实现安全抽象，例如

fn index_multiple_mut<'a, T>(input: &'a mut [Vec<T>], indices: &[(usize, usize)]) -> Vec<&'a mut T>

首先检查所有索引是否不同，然后使用unsafe和一些指针强制转换（可能使用transmute）来创建结果向量。

第三种可能的方法是以一种聪明的方式使用split_at_mut()方法，但我不确定它是否可行，如果是，它可能不太方便。

Answer 3

最后，我在#rust

的帮助下制作了一个自定义迭代器

我type我的结构出来给你实际的代码。正如#rust中的人所指出的那样，你不能安全地从迭代器返回&mut而不使用另一个使用unsafe的迭代器，并且假设这里的数学很简单以确保它不会出错，不安全是要走的路。

type FieldSquare = u8;

use std::iter::Iterator;

pub struct SurroundingSquaresIter<'a> {
    squares: &'a mut Vec<Vec<FieldSquare>>,
    center_x: usize,
    center_y: usize,
    current_x: usize,
    current_y: usize,
}

pub trait HasSurroundedSquares<'a> {
    fn surrounding_squares(&'a mut self, x: usize, y:usize) -> SurroundingSquaresIter<'a>;
}

impl<'a> HasSurroundedSquares<'a> for Vec<Vec<FieldSquare>> {
    fn surrounding_squares(&'a mut self, x: usize, y:usize) -> SurroundingSquaresIter<'a> {
        SurroundingSquaresIter {
            squares: self,
            center_x: x,
            center_y: y,
            current_x: if x == 0 { x } else { x - 1 },
            current_y: if y == 0 { y } else { y - 1 },
        }
    }
}

impl<'a> Iterator for SurroundingSquaresIter<'a> {
    type Item = &'a mut FieldSquare;

    fn next(&mut self) -> Option<&'a mut FieldSquare> {
        if self.current_y + 1 > self.squares.len() || self.current_y > self.center_y + 1 {
            return None;
        }

        let ret_x = self.current_x;
        let ret_y = self.current_y;

        if self.current_x < self.center_x + 1 && self.current_x + 1 < self.squares[self.current_y].len() {
            self.current_x += 1;
        }
        else {
            self.current_x = if self.center_x == 0 { self.center_x } else { self.center_x - 1 };
            self.current_y += 1;
        }

        if ret_x == self.center_x && ret_y == self.center_y {
            return self.next();
        }

        Some(unsafe { &mut *(&mut self.squares[ret_y][ret_x] as *mut _) })
    }
}

在Vec <vec <object>＆gt;中围绕特定索引的元素的迭代器

3 个答案: