如何获取 Vec 中元素的多个可变引用？

Question

我有一个大型嵌套数据结构，想取出一些部分来进行处理。最终，我想将部分发送到多个线程进行更新，但我想先了解一下我下面说明的简单示例。在 C 中，我只会组装一个相关指针的数组。这在 Rust 中似乎是可行的，因为内部向量永远不需要多个可变引用。这是示例代码。

fn main() {
    let mut data = Data::new(vec![2, 3, 4]);
    // this works
    let slice = data.get_mut_slice(1);
    slice[2] = 5.0;
    println!("{:?}", data);

    // what I would like to do
    // let slices = data.get_mut_slices(vec![0, 1]);
    // slices[0][0] = 2.0;
    // slices[1][0] = 3.0;
    // println!("{:?}", data);
}

#[derive(Debug)]
struct Data {
    data: Vec<Vec<f64>>,
}

impl Data {
    fn new(lengths: Vec<usize>) -> Data {
        Data {
            data: lengths.iter().map(|n| vec![0_f64; *n]).collect(),
        }
    }

    fn get_mut_slice(&mut self, index: usize) -> &mut [f64] {
        &mut self.data[index][..]
    }

    // doesnt work
    // fn get_mut_slices(&mut self, indexes: Vec<usize>) -> Vec<&mut [f64]> {
    //     indexes.iter().map(|i| self.get_mut_slice(*i)).collect()
    // }
}

Answer 1

只要您非常小心，使用安全的 Rust 就可以做到这一点。诀窍是利用标准库中安全

.iter_mut()

和

.nth()

上的

Vec

方法背后的不安全 Rust 代码。这是一个工作示例，其中包含在上下文中解释代码的注释：

fn main() {
    let mut data = Data::new(vec![2, 3, 4]);

    // this works
    let slice = data.get_mut_slice(1);
    slice[2] = 5.0;
    println!("{:?}", data);

    // and now this works too!
    let mut slices = data.get_mut_slices(vec![0, 1]);
    slices[0][0] = 2.0;
    slices[1][0] = 3.0;
    println!("{:?}", data);
}

#[derive(Debug)]
struct Data {
    data: Vec<Vec<f64>>,
}

impl Data {
    fn new(lengths: Vec<usize>) -> Data {
        Data {
            data: lengths.iter().map(|n| vec![0_f64; *n]).collect(),
        }
    }

    fn get_mut_slice(&mut self, index: usize) -> &mut [f64] {
        &mut self.data[index][..]
    }

    // now works!
    fn get_mut_slices(&mut self, mut indexes: Vec<usize>) -> Vec<&mut [f64]> {
        // sort indexes for easier processing
        indexes.sort();
        let index_len = indexes.len();

        // early return for edge case
        if index_len == 0 {
            return Vec::new();
        }

        // check that the largest index is in bounds
        let max_index = indexes[index_len - 1];
        if max_index > self.data.len() {
            panic!("{} index is out of bounds of data", max_index);
        }

        // check that we have no overlapping indexes
        indexes.dedup();
        let uniq_index_len = indexes.len();
        if index_len != uniq_index_len {
            panic!("cannot return aliased mut refs to overlapping indexes");
        }

        // leverage the unsafe code that's written in the standard library
        // to safely get multiple unique disjoint mutable references
        // out of the Vec
        let mut mut_slices_iter = self.data.iter_mut();
        let mut mut_slices = Vec::with_capacity(index_len);
        let mut last_index = 0;
        for curr_index in indexes {
            mut_slices.push(
                mut_slices_iter
                    .nth(curr_index - last_index)
                    .unwrap()
                    .as_mut_slice(),
            );
            last_index = curr_index;
        }

        // return results
        mut_slices
    }
}

游乐场

---

我相信我了解到的是，Rust 编译器在这种情况下需要一个迭代器，因为这是它知道每个 mut 切片来自不同向量的唯一方法。

编译器实际上并不知道这一点。它只知道迭代器返回 mut 引用。底层实现使用不安全的 Rust，但方法

iter_mut()

本身是安全的，因为该实现保证只发出每个 mut ref 一次，并且所有 mut ref 都是唯一的。

如果在 for 循环中创建了另一个

mut_slices_iter

（可能会获取相同的数据两次），编译器会抱怨吗？

是的。在

iter_mut()

上调用

Vec

会可变地借用它，并且相同数据的重叠可变借用违反 Rust 的所有权规则，因此您不能在同一范围内调用

iter_mut()

两次（除非第一次调用返回的迭代器被删除）在第二次通话之前）。

我也说得对吗

.nth

方法将调用

next()

n 次，因此最终是第一个轴上的 theta(n) ？

不完全是。这是

nth

的默认实现，但是通过在

iter_mut()

上调用

Vec

返回的迭代器使用 自己的自定义实现，并且它似乎跳过迭代器中过去的项目而不调用

next()

，因此它应该与如果您只是定期对

Vec

进行索引，即使用

.nth()

获取 3 个随机索引的项目，在 10000 个项目的迭代器上与在 10 个项目的迭代器上一样快，尽管这仅适用于从支持快速随机访问的集合创建的迭代器，例如

Vec

s。

Answer 2

如果您想要唯一索引，这实际上更有意义，因为您不能/不应该对同一元素有两个可变引用。您可以使用

HashSet

代替

Vec

并使用一些迭代器组合：

    fn get_mut_slices(&mut self, indexes: HashSet<usize>) -> Vec<&mut [f64]> {
        self.data
            .iter_mut()
            .enumerate()
            .filter(|(i, _)| indexes.contains(i))
            .map(|(_, e)| e.as_mut_slice())
            .collect()
    }

游乐场

您仍然可以使用

Vec

来实现此选项，但使用

contains

时效率会低得多:

    fn get_mut_slices(&mut self, indexes: Vec<usize>) -> Vec<&mut [f64]> {
        self.data
            .iter_mut()
            .enumerate()
            .filter(|(i, _)| indexes.contains(i))
            .map(|(_, e)| e.as_mut_slice())
            .collect()
    }

Answer 3

您可以使用

split_at_mut

，但如果您需要两个以上的索引或顺序未知，则效果不佳。

其他选项是每晚的

get_many_mut

，但请注意它必须对您提供的索引进行某种处理。如果您知道索引的数量、顺序或编译时的值，这可能不是最佳选择。

为了稳定，这个板条箱以最高效的方式解决了这个问题，并针对一些不同的场景优化了一些方法和宏：https://github.com/mcmah309/indices

fn get_mut_slices(&mut self, indexes: Vec<usize>) -> Vec<&mut [f64]> {
    indices::indices_slice(self.data, &mut indexes)
}