Если у меня есть структура, которая инкапсулирует два члена и обновляет один на основе другого, это нормально, пока я делаю это следующим образом:
struct A {
value: i64
}
impl A {
pub fn new() -> Self {
A { value: 0 }
}
pub fn do_something(&mut self, other: &B) {
self.value += other.value;
}
pub fn value(&self) -> i64 {
self.value
}
}
struct B {
pub value: i64
}
struct State {
a: A,
b: B
}
impl State {
pub fn new() -> Self {
State {
a: A::new(),
b: B { value: 1 }
}
}
pub fn do_stuff(&mut self) -> i64 {
self.a.do_something(&self.b);
self.a.value()
}
pub fn get_b(&self) -> &B {
&self.b
}
}
fn main() {
let mut state = State::new();
println!("{}", state.do_stuff());
}
То есть, когда я прямо ссылаюсь на self.b. Но когда я меняю do_stuff() на это:
pub fn do_stuff(&mut self) -> i64 {
self.a.do_something(self.get_b());
self.a.value()
}
Компилятор жалуется: cannot borrow `*self` as immutable because `self.a` is also borrowed as mutable.
Что, если мне нужно сделать что-то более сложное, чем просто вернуть член, чтобы получить аргумент для a.do_something()? Должен ли я создать функцию, которая возвращает b по значению и сохранить его в привязке, а затем передать эту привязку do_something()? Что, если b сложное?
Что еще более важно, насколько я понимаю, от какой небезопасности памяти меня спасает компилятор?
