在傳遞要迭代的向量時，如何調用迭代器的函數？

Question

我正在嘗試遍歷結構的向量，並從迭代器調用函數，同時還將向量傳遞給它。

我收到此錯誤：

error[E0502]: cannot borrow `self.members` as immutable because it is also borrowed as mutable
  --> main.rs:40:29
   |
39 |             for member in self.members.iter_mut() {
   |                           ------------ mutable borrow occurs here
40 |                 member.func(self.members.to_vec());
   |                             ^^^^^^^^^^^^ immutable borrow occurs here
41 |             }
   |             - mutable borrow ends here

error[E0502]: cannot borrow `self.members` as immutable because it is also borrowed as mutable
  --> main.rs:40:29
   |
39 |             for member in self.members.iter_mut() {
   |                           ------------ mutable borrow occurs here
40 |                 member.func(self.members.to_vec());
   |                             ^^^^^^^^^^^^ immutable borrow occurs here
41 |             }
   |             - mutable borrow ends here

我了解問題所在，但並不真正了解解決問題的語法。 我曾嘗試過各種不同的操作，例如克隆和復制，但似乎無法使其正常工作。

struct Member {
    data: i32,
}

impl Copy for Member {}
impl Clone for Member {
    fn clone(&self) -> Member {
        *self
    }
}

impl Member {
    pub fn new(data: i32) -> Member {
        Member { data: data }
    }
    pub fn func(&mut self, members: Vec<Member>) {
        let mut exists = false;
        for member in members.iter() {
            if member.data == self.data + 1 {
                exists = true;
            }
        }
        if !exists {
            self.data += 1;
        }
    }
}

struct List {
    members: Vec<Member>,
}

impl List {
    pub fn new() -> List {
        let mut members = Vec::new();
        members.push(Member::new(0));
        members.push(Member::new(1));
        members.push(Member::new(3));
        List { members: members }
    }

    pub fn call_all(&mut self) {
        // Here is the issue
        for member in self.members.iter_mut() {
            member.func(self.members.to_vec());
        }
    }
}

fn main() {
    let mut list = List::new();
    list.call_all();
}

看來這將是一個簡單的修復。 如果這看起來過於通用，請查看完整代碼的此回購 。

Answer 1

了解借閱限制很重要。 只能有一個可變的借項，只要該借項是“活動的”，就不能使用其他任何方式訪問該借項。 Rust不允許您以不同的方式訪問同一事物，而其中一種方式則允許突變。 這就是我們獲得所有這些良好安全保證的方式。

在你的代碼借用self.members性情不定地使用iter_mut作為循環結構的一部分。 這就是為什么編譯器不允許您在循環內再次訪問self.members的原因。

我不知道您的代碼的目的是什么，但這似乎可以計算出您想計算的內容：

fn main() {
    let mut v = vec![0, 1, 3];
    for i in 0..v.len() {
        if !v.contains(&(v[i] + 1)) {
            v[i] += 1;
        }
    }
    println!("{:?}", &v[..]);
}

這里，向量不作為循環構造的一部分借用。 我們改為遍歷索引。 if表達式中的條件涉及兩個臨時的不可變借位，這很好。 在if表達式的身體v是臨時借用性情不定地改變的價值i個元素，而沒有其他借是活的。 沒關系。