如何将实现多Trait的Struct以&mut形式传入函数并解决E0499错误

问题场景 #

我遇到的编译错误为error[E0499]: cannot borrow *dog as mutable more than once at a time，简化后的代码如下：

trait Swimmer {
    fn swim(&mut self);
}

trait Walker {
    fn walk(&mut self);
}

struct Fish {}

impl Swimmer for Fish {
    fn swim(&mut self) {}
}

struct Turtle {}

impl Walker for Turtle {
    fn walk(&mut self) {}
}

struct Dog {
    energy: usize,
}

impl Swimmer for Dog {
    fn swim(&mut self) {
        self.energy -= 1;
    }
}

impl Walker for Dog {
    fn walk(&mut self) {
        self.energy -= 1;
    }
}

fn move_around(walker: &mut dyn Walker, swimmer: &mut dyn Swimmer) {
    walker.walk();
    swimmer.swim();
}

fn main() {
    // 编译失败：error[E0499]: cannot borrow `*dog` as mutable more than once at a time
    let dog = &mut Dog { energy: 100 };
    move_around(dog, dog);

    // 此写法可正常运行
    // move_around(&mut Turtle {}, &mut Fish {});
}

我的核心需求：

• Walker和Swimmer trait都会操作Dog的共享字段energy，因此Dog实现这两个trait是合理的
• 希望保留walk后执行swim的顺序逻辑
• 不想使用RefCell，也不想通过拆分Dog的共享字段来解决（拆分后处理共享状态会复杂化）

可行解决方案 #

方案1：泛型版本的move_around（推荐） #

新增一个带 trait bounds 的泛型函数，编译器能明确判断同一实例的两次可变借用是安全的——它知道两个trait作用于同一类型，且调用顺序明确：

fn move_around<T: Walker + Swimmer>(entity: &mut T) {
    entity.walk();
    entity.swim();
}

调用方式修改为：

fn main() {
    let mut dog = Dog { energy: 100 };
    move_around(&mut dog);
}

这个方案完全满足需求：既保留了先行走后游泳的顺序，无需修改Dog结构，也不需要依赖内部可变性工具。

方案2：保留原函数签名的unsafe方案（不推荐） #

如果必须保留原有的move_around函数签名（比如有其他代码依赖该签名），可以通过unsafe绕过借用检查，但需要自行保证内存安全：

fn main() {
    let mut dog = Dog { energy: 100 };
    let walker = &mut dog as &mut dyn Walker;
    // 强制将同一可变引用转换为Swimmer trait对象
    let swimmer = unsafe { &mut *(dog as *mut Dog) as &mut dyn Swimmer };
    move_around(walker, swimmer);
}

⚠️ 注意：该方法会跳过Rust的借用规则保护，若move_around中出现不符合内存安全的操作（如同时修改同一字段），会引发未定义行为，仅在完全确认逻辑安全时使用。

错误原因说明 #

Rust的借用规则禁止同时存在多个可变引用。原代码中把同一个&mut Dog同时传给两个参数，编译器无法确定这两个trait对象是否会同时修改共享状态，因此拒绝编译。而泛型版本的函数因明确了类型同时实现两个trait，编译器能确认两次调用是顺序执行的，不存在同时可变借用的问题。

内容的提问来源于stack exchange，提问作者PWolf