特征默认方法中的多个自我借用

Question

我运行遇到借用检查器的问题。我有一个特征 (Physics)，它有 getter（例如 velocity）和 setter（例如 velocity_mut）。它还具有使用 getter 和 setter 的默认方法 accelerate 和 apply_force。为什么多次借用不好，解决这个问题的方法是什么？这是一条错误消息：

       13:18    rustc           error       cannot borrow `*self` as immutable because it is also borrowed as mutable
                                            immutable borrow occurs here
       12:11    rustc           hint        mutable borrow occurs here
       12:11    rustc           hint        argument requires that `*self` is borrowed for `'static`

use gdnative::prelude::*;

// Running into issues with the borrow checker

trait Physics {
    fn apply_force(&mut self, force: &mut Vector2, truncate: bool) {
        let max_force = self.max_force();

        if force.square_length() > max_force * max_force && truncate {
            *force = force.normalize() * max_force;
        }
        let a = self.acceleration_mut();// Line 12
        *a += *force / self.mass();//Line 13
        self.accelerate(truncate);
    }
    fn accelerate(&mut self, truncate: bool) {
        let v = self.velocity_mut();
        *v += self.acceleration();

        let max_speed = self.max_speed();

        if v.square_length() > max_speed * max_speed && truncate {
            *v = v.normalize() * max_speed;
        }
    }
    fn velocity(&self) -> Vector2;
    fn velocity_mut(&mut self) -> &mut Vector2;
    fn acceleration(&self) -> Vector2;
    fn acceleration_mut(&mut self) -> &mut Vector2; 
    fn max_speed(&self) -> f32;
    fn max_speed_mut(&mut self) -> &mut f32;
    fn max_force(&self) -> f32;
    fn max_force_mut(&mut self) -> &mut f32;
    fn mass(&self) -> f32;
    fn mass_mut(&mut self) -> &mut f32;
}

struct Actor {
    velocity: Vector2,
    acceleration: Vector2,
    max_speed: f32,
    max_force: f32,
    mass: f32
}

impl Physics for Actor {
    fn velocity(&self) -> Vector2 {
        self.velocity
    }
    fn velocity_mut(&mut self) -> &mut Vector2 {
        &mut self.velocity
    }
    fn acceleration(&self) -> Vector2 {
        self.acceleration    
    }
    fn acceleration_mut(&mut self) -> &mut Vector2 {
        &mut self.acceleration
    }
    fn mass(&self) -> f32 {
        self.mass    
    }
    fn mass_mut(&mut self) -> &mut f32 {
        &mut self.mass    
    }
    fn max_speed(&self) -> f32 {
        self.max_speed    
    }
    fn max_speed_mut(&mut self) -> &mut f32 {
        &mut self.max_speed    
    }
    fn max_force(&self) -> f32 {
        self.max_force    
    }
    fn max_force_mut(&mut self) -> &mut f32 {
        &mut self.max_force
    }
}

fn main() {

}

Answer 1

在存在可变借用的情况下不能不可变借用的原因是，否则您可以使用可变借用来修改由不可变借用表示的基础数据。由于不可变借用（显然）不应该改变，借用检查器不能承担风险（即使你“知道”可变借用不会影响不可变借用）。

在这种情况下，我相信您可以通过在调用 self.acceleration_mut()

之前将 self.mass() 分配给本地来解决这个问题

let mass = self.mass();
let a = self.acceleration_mut();
*a += *force / mass;

由于 mass 只是一个 f32，它被复制到 return，所以不可变借用将在下一行之前完成。

Answer 2

由于“吸气剂”return 拥有值，另一种设计是使用局部变量来计算结果，并仅在末尾分配它（通过可变引用）：

    fn apply_force(&mut self, force: &mut Vector2, truncate: bool) {
        let max_force = self.max_force();

        if force.square_length() > max_force * max_force && truncate {
            *force = force.normalize() * max_force;
        }
        let mut a = self.acceleration(); // Line 12
        a += *force / self.mass(); //Line 13
        *self.acceleration_mut() = a;
        self.accelerate(truncate);
    }
    fn accelerate(&mut self, truncate: bool) {
        let mut v = self.velocity();
        v += self.acceleration();

        let max_speed = self.max_speed();

        if v.square_length() > max_speed * max_speed && truncate {
            v = v.normalize() * max_speed;
        }

        *self.velocity_mut() = v;
    }

避免使用局部变量（例如，如果您假设基础值是克隆的，并且这是昂贵的），是很棘手的，因为很难通过可变引用锁定方法的整个长度（或左右）管理。

特征默认方法中的多个自我借用

multiple self borrows within trait default methods

rust

borrow