Cannot borrow as mutable because it is also borrowed as immutable

匿名 (未验证) 提交于 2019-12-03 02:28:01

问题:

I am learning Rust and I don't quite get why this is not working.

#[derive(Debug)] struct Node {     value: String, }  #[derive(Debug)] pub struct Graph {     nodes: Vec<Box<Node>>, }  fn mk_node(value: String) -> Node {     Node { value } }  pub fn mk_graph() -> Graph {     Graph { nodes: vec![] } }  impl Graph {     fn add_node(&mut self, value: String) {         if let None = self.nodes.iter().position(|node| node.value == value) {             let node = Box::new(mk_node(value));             self.nodes.push(node);         };     }      fn get_node_by_value(&self, value: &str) -> Option<&Node> {         match self.nodes.iter().position(|node| node.value == *value) {             None => None,             Some(idx) => self.nodes.get(idx).map(|n| &**n),         }     } }   #[cfg(test)] mod tests {     use super::*;      #[test]     fn some_test() {         let mut graph = mk_graph();          graph.add_node("source".to_string());         graph.add_node("destination".to_string());          let source = graph.get_node_by_value("source").unwrap();         let dest = graph.get_node_by_value("destination").unwrap();          graph.add_node("destination".to_string());     } } 

(playground)

This has the error

error[E0502]: cannot borrow `graph` as mutable because it is also borrowed as immutable   --> src/main.rs:50:9    | 47 |         let source = graph.get_node_by_value("source").unwrap();    |                      ----- immutable borrow occurs here ... 50 |         graph.add_node("destination".to_string());    |         ^^^^^ mutable borrow occurs here 51 |     }    |     - immutable borrow ends here 

This example from Programming Rust is quite similar to what I have but it works:

pub struct Queue {     older: Vec<char>,   // older elements, eldest last.     younger: Vec<char>, // younger elements, youngest last. }  impl Queue {     /// Push a character onto the back of a queue.     pub fn push(&mut self, c: char) {         self.younger.push(c);     }      /// Pop a character off the front of a queue. Return `Some(c)` if there /// was a character to pop, or `None` if the queue was empty.     pub fn pop(&mut self) -> Option<char> {         if self.older.is_empty() {             if self.younger.is_empty() {                 return None;             }              // Bring the elements in younger over to older, and put them in // the promised order.             use std::mem::swap;             swap(&mut self.older, &mut self.younger);             self.older.reverse();         }          // Now older is guaranteed to have something. Vec's pop method // already returns an Option, so we're set.         self.older.pop()     }      pub fn split(self) -> (Vec<char>, Vec<char>) {         (self.older, self.younger)     } }  pub fn main() {     let mut q = Queue {         older: Vec::new(),         younger: Vec::new(),     };      q.push('P');     q.push('D');      assert_eq!(q.pop(), Some('P'));     q.push('X');      let (older, younger) = q.split(); // q is now uninitialized.     assert_eq!(older, vec!['D']);     assert_eq!(younger, vec!['X']); } 

回答1:

A MCVE of your problem can be reduced to this:

fn main() {     let mut items = vec![1];     let item = items.last();     items.push(2); } 
error[E0502]: cannot borrow `items` as mutable because it is also borrowed as immutable  --> src/main.rs:4:5   | 3 |     let item = items.last();   |                ----- immutable borrow occurs here 4 |     items.push(2);   |     ^^^^^ mutable borrow occurs here 5 | }   | - immutable borrow ends here 

You are encountering the exact problem that Rust was designed to prevent. You have a reference pointing into the vector and are attempting to insert into the vector. Doing so might require that the memory of the vector be reallocated, invalidating any existing references. If that happened and you used the value in item, you'd be accessing uninitialized memory, potentially causing a crash.

In this particular case, you aren't actually using item (or source, in the original) so you could just... not call that line. I assume you did that for some reason, so you could wrap the references in a block so that they go away before you try to mutate the value again:

fn main() {     let mut items = vec![1];     {         let item = items.last();     }     items.push(2); } 

This trick will no longer be needed whenever non-lexical lifetimes are implemented, but the underlying restriction will still remain ― you cannot have a mutable reference while there are other references to the same thing. This is one of the rules of references covered in The Rust Programming Language.

In other cases, you can copy or clone the value in the vector. The item will no longer be a reference and you can modify the vector as you see fit:

fn main() {     let mut items = vec![1];     let item = items.last().cloned();     items.push(2); } 

If your type isn't cloneable, you can transform it into a reference-counted value (such as Rc or Arc) which can then be cloned. You may or may not also need to use interior mutability:

struct NonClone;  use std::rc::Rc;  fn main() {     let mut items = vec![Rc::new(NonClone)];     let item = items.last().cloned();     items.push(Rc::new(NonClone)); } 

this example from Programming Rust is quite similar

No, it's not, seeing as how it doesn't use references at all.

See also



回答2:

Try to put your immutable borrow inside a block {...}. This ends the borrow after the block.

#[cfg(test)] mod tests {     use super::*;      #[test]     fn some_test() {         let mut graph = mk_graph();          graph.add_node("source".to_string());         graph.add_node("destination".to_string());          {             let source = graph.get_node_by_value("source").unwrap();             let dest = graph.get_node_by_value("destination").unwrap();         }          graph.add_node("destination".to_string());     } } 


易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!