0

我正在为具有共享引用的对象创建工厂方法。编译器看不到来自 a 的对象Vec没有在本地范围之外被引用，并且新创建的对象没有链接到原始对象。

我该如何解决这个问题，我错过了什么？

#[derive(Debug)]
pub struct A {}

pub struct B<'b> {
    a: &'b A,
}

impl<'b> B<'b> {
    pub fn new(a: &'b A) -> B {
        B { a: a }
    }

    pub fn combine(&self, _: &B) -> B {
        B::new(self.a)
    }
}

pub fn main() {
    let a: A = A {};

    let mut v1: Vec<B> = vec![];
    v1.push(B::new(&a));
    v1.push(B::new(&a));

    let mut v2: Vec<B> = vec![];
    {
        let b1 = &v1[0]; // << Mutable borrow occurs here - why?
        let b2 = &v1[1];
        let c = b1.combine(&b2);
        v2.push(c)
    }
    v1.clear(); // Error: Cannot borrow due to mutable borrow above
    println!("{:?}", v2[0].a);
}

error[E0502]: cannot borrow `v1` as mutable because it is also borrowed as immutable
  --> src/main.rs:32:5
   |
27 |         let b1 = &v1[0]; // << Mutable borrow occurs here - why?
   |                   -- immutable borrow occurs here
...
32 |     v1.clear(); // Error: Cannot borrow due to mutable borrow above
   |     ^^^^^^^^^^ mutable borrow occurs here
33 |     println!("{:?}", v2[0].a);
   |                      -- immutable borrow later used here

不，对不起，我还是不太明白。

这是一个更简单的例子，没有向量：

    let a:A = A {  };
    
    let mut b1 = B::new(&a);
    let mut b2 = B::new(&a);
    
    let c = &b1.combine(&b2);
    //      ^^^ This creates a mutable reference to b1. How to avoid?
    b1 = B::new(&a);
    b2 = B::new(&a);
    
    println!("{:?}",c.a);

出于某种原因，对对象的方法调用将使编译器假定我有对该对象的引用，尽管c没有引用b1. 我该如何解决？

如何声明combine()-method 是不可变的？

4

0 回答 0