3

我有一个 2 Vecs 的结构。我希望能够在修改另一个的同时迭代一个。这是一个示例程序：

use std::slice;

struct S {
    a: Vec<i32>,
    b: Vec<i32>
}

impl S {
    fn a_iter<'a>(&'a self) -> slice::Iter<i32>  {
        self.a.iter()
    }
    fn a_push(&mut self, val: i32) {
        self.a.push(val);
    }
    fn b_push(&mut self, val: i32) {
        self.b.push(val);
    }
}

fn main() {
    let mut s = S { a: Vec::new(), b: Vec::new() };
    s.a_push(1);
    s.a_push(2);
    s.a_push(3);

    for a_val in s.a_iter() {
        s.b_push(a_val*2);
    }
}

但是有这个编译器错误：

$ rustc iterexample.rs 
iterexample.rs:28:9: 28:10 error: cannot borrow `s` as mutable because it is also borrowed as immutable
iterexample.rs:28         s.b_push(a_val*2);
                           ^
note: in expansion of for loop expansion
 iterexample.rs:26:5: 29:6 note: expansion site
iterexample.rs:26:18: 26:19 note: previous borrow of `s` occurs here; the immutable borrow prevents subsequent moves or mutable borrows of `s` until the borrow ends
iterexample.rs:26     for a_val in s.a_iter() {
                                   ^
note: in expansion of for loop expansion
iterexample.rs:26:5: 29:6 note: expansion site
iterexample.rs:29:6: 29:6 note: previous borrow ends here
iterexample.rs:26     for a_val in s.a_iter() {
iterexample.rs:27         println!("Looking at {}", a_val);
iterexample.rs:28         s.b_push(a_val*2);
iterexample.rs:29     }
                      ^
note: in expansion of for loop expansion
iterexample.rs:26:5: 29:6 note: expansion site
error: aborting due to previous error

我了解编译器在抱怨什么。我self在 for 循环中借用了，因为我仍在循环它。

从概念上讲，应该有一种方法可以做到这一点。我只是在修改s.b，而不是修改我正在循环的东西（s.a）。无论如何要编写我的程序来演示这种分离，并允许这种程序编译？

这是一个较大程序的简化示例，因此我需要保持一般结构相同（一个结构有一些东西，其中一个将被迭代，另一个将被更新）。

4

4 回答 4

4

如果您使用s.a.it而不是s.a_iter(). 您当前的解决方案不起作用，因为返回的迭代器s.a_iter()保留了s其自身具有相同生命周期的s引用，因此在该引用存在之前，您不能在内部借用可变的东西s。具体来说，这是因为：

评估泛型参数时，编译器在函数调用边界处停止

（在你的情况下的生命周期）

这里有一个很好的答案，其中包含对一个非常相似的问题的完整解释： 不能借用 `self.x` 作为不可变的，因为 `*self` 也被借用为可变的

编辑

一个可能的解决方案是将操作带入内部，S而不是从S. 您可以在S这样的方法中定义：

fn foreach_in_a_push_to_b<F>(&mut self, func: F) where F : Fn(&i32) -> i32 {
    for a_val in self.a.iter() {
        self.b.push(func(a_val));
    }
}

接着

s.foreach_in_a_push_to_b(|&x| x * 2);
于 2015-07-02T20:24:10.893 回答
2

根本问题是借用检查器没有足够的信息来证明你的代码是安全的。它停在功能边界处。您可以通过编写一个拆分引用的方法来解决此问题，以便编译器确实拥有它需要的信息：

struct S {
    a: Vec<i32>,
    b: Vec<i32>
}

impl S {
    fn a_push(&mut self, val: i32) {
        self.a.push(val);
    }
    fn split_a_mut_b<'a>(&'a mut self) -> (&'a Vec<i32>, &'a mut Vec<i32>) {
        (&self.a, &mut self.b)
    }
}

fn main() {
    let mut s = S { a: Vec::new(), b: Vec::new() };
    s.a_push(1);
    s.a_push(2);
    s.a_push(3);

    let (a, b) = s.split_a_mut_b();

    for a_val in a.iter() {
        b.push(a_val*2);
    }
}

他们这里的关键是在 内split_a_mut_b，编译器可以证明两个借用不重叠。您可以使用的另一种模式（可以让您保留更多原始 API）是将值临时分解为可变和不可变部分：

use std::slice;

#[derive(Debug)]
struct S {
    a: Vec<i32>,
    b: Vec<i32>
}

impl S {
    fn a_iter(&self) -> slice::Iter<i32>  {
        self.a.iter()
    }
    fn a_push(&mut self, val: i32) {
        self.a.push(val);
    }
    fn b_push(&mut self, val: i32) {
        self.b.push(val);
    }
    fn split_a_mut_b<F, R>(&mut self, f: F) -> R
    where F: FnOnce(&Self, &mut Self) -> R {
        use std::mem::swap;

        // Break off the mutable part(s) (or the immutable parts if there
        // are less of those).
        let mut temp = S { a: vec![], b: vec![] };
        swap(&mut self.b, &mut temp.b);

        // Call the closure.
        let result = f(self, &mut temp);

        // Glue the value back together.
        swap(&mut self.b, &mut temp.b);

        result
    }
}

fn main() {
    let mut s = S { a: Vec::new(), b: Vec::new() };
    s.a_push(1);
    s.a_push(2);
    s.a_push(3);

    s.split_a_mut_b(|imm, muta| {
        for a_val in imm.a_iter() {
            muta.b_push(a_val*2);
        }
    });

    println!("{:?}", s);
}

这并不是非常低效。这种方法绝对不会引入堆活动；我们只是在改变指针。

于 2015-07-03T02:37:43.397 回答
0

使用原始指针，您可以将结构别名为第二个变量——Rust 会将它们视为两个不同的变量，并让您借用不可变的部分而不会抱怨。

let s_alias = &s as *const S;
let a_iter = unsafe { (*s_alias).a_iter() };

for a_val in a_iter {
    s.b_push(a_val*2);
}

操场

我欢迎对此提出第二意见，但至少在这个例子中，我看不出它如何导致任何内存安全问题。

于 2015-07-02T20:27:41.130 回答
0

我想我已经使用宏“解决”了这个问题。如果我使用以下代码，它可以工作：

use std::slice;

struct S {
    a: Vec<i32>,
    b: Vec<i32>
}

impl S {
    fn a_push(&mut self, val: i32) {
        self.a.push(val);
    }
}

macro_rules! a_iter {
    ($x: expr) => {
        { $x.a.iter() }
    }
}

macro_rules! b_push {
    ($x: expr, $val: expr) => {
        $x.b.push($val);
    }
}

fn main() {
    let mut s = S { a: Vec::new(), b: Vec::new() };
    s.a_push(1);
    s.a_push(2);
    s.a_push(3);

    let iter = a_iter!(s);

    for a_val in iter {
        println!("Looking at {}", a_val);
        b_push!(s, a_val*2);
    }
}

在这里，我将a_iterandb_push代码移到了一个宏中。编译代码时，宏将被扩展，就好像我们没有使用抽象函数一样。然而，对于编写代码，该功能被抽象掉了。

我不确定它们是好主意还是坏主意。

于 2015-07-05T12:20:39.987 回答