2

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

       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() {

}
4

2 回答 2

1

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

在这种情况下，我相信您可以通过self.mass()在拨打电话之前分配给本地人来解决这个问题self.acceleration_mut()

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

由于 mass 只是 a f32，它在返回时被复制，因此不可变借用将在下一行之前完成。

于 2021-01-15T06:27:47.730 回答
0

由于“getter”返回拥有的值，另一种设计是使用局部变量来计算结果，并仅在最后分配它（通过可变引用）：

    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;
    }

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

于 2021-01-15T17:41:13.767 回答