Rust中为引用实现trait时如何避免self被移动？

trait A的a方法按值接收self，调用时会拿走实现实例的所有权。在泛型函数中，编译器仅知道参数满足A约束，无法预知具体类型是否支持重复复制/复用，第一次调用c.a()就会将c的所有权移入方法，第二次调用就会触发移动后使用错误。
另外你当前直接为引用类型&B、&mut C实现trait的写法不符合Rust惯例：trait应该为原始类型实现，方法通过&self/&mut self声明接收者，由Rust自动处理引用的复制、重借用逻辑。

推荐写法（符合Rust设计规范） #

调整trait和对应实现，将方法接收者改为共享引用（B的实现只需要共享访问，C的可变引用可以自动转换为共享引用调用），然后修改test函数签名为接收共享引用的泛型参数：

trait A {
  fn a(&self);
}

struct B;
impl A for B {
   fn a(&self) {}
}

struct C;
impl A for C {
    fn a(&self) {}
}

// 修改后的函数签名
fn test(c: &impl A) {
    c.a();
    c.a();
}

fn main() {
    let b = B;
    test(&b); // 支持传入&B
    let mut c = C;
    test(&mut c); // 支持传入&mut C，可变引用自动转换为共享引用
}

如果C的a方法确实需要可变访问，将trait方法改为fn a(&mut self)，对应impl调整后，函数签名改为fn test(c: &mut impl A)即可，此时仅支持传入&mut C，符合Rust可变借用的独占规则。

保留原有trait/impl的兼容写法 #

如果必须保留原有trait和为引用类型实现的逻辑，无法仅通过单一函数签名直接兼容两种入参（&mut C不支持Copy，无法像&B一样自动复制），需要通过辅助trait统一处理两种入参的调用逻辑：

// 保留原有trait和impl不变
trait A {
  fn a(self);
}
struct B;
impl A for &B {
   fn a(self) {}
}
struct C;
impl A for &mut C {
    fn a(self) {}
}

// 辅助trait统一处理两种入参的复用逻辑
trait TestCompat {
    fn call_a_twice(self);
}
impl<'a> TestCompat for &'a B {
    fn call_a_twice(self) {
        self.a();
        self.a(); // &B实现了Copy，可直接复制调用
    }
}
impl<'a> TestCompat for &'a mut C {
    fn call_a_twice(mut self) {
        (&mut *self).a(); // 重借用可变引用，调用结束后归还所有权
        (&mut *self).a();
    }
}

// 修改后的test函数签名
fn test(c: impl TestCompat) {
    c.call_a_twice();
}

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