Question

这就是我想要实现的目标：

trait Foo {
    fn readonly(&self) -> i32;
    fn modify(&mut self, val: i32);
}

struct FooWrapper<'a> {
    foo: &'a Foo,
}

impl<'a> FooWrapper<'a> {
    fn readonly(&self) -> i32 {
        self.foo.readonly()
    }

    fn modify(&mut self, val: i32) {
        self.foo.modify(val);//!!!
    }
}

作为输入，我得到&Foo和&mut Foo，如： fn func(a: &Foo, b: &mut Foo)。

我希望然后将它们包装在FooWraper中，并使用它的方法使用Foo。

但是，如您所见，编译器不允许使用标有//!!!的代码。

任何解决方法都可以解决这个问题而不需要代码重复：

struct FooWrapper<'a> {
    foo: &'a Foo,
}
struct FooWrapperMut<'a> {
    foo: &'a mut Foo,
}
impl<'a> FooWrapper<'a>..
impl<'a> FooWrapperMut<'a>..

Answer 1

只需将foo作为可变参考。然后可以通过可变或不可变的方式借用它。

struct FooWrapper<'a> {
    foo: &'a mut Foo,
}

&mut T引用始终可以强制转换为&T。

如果您希望为不可变引用提供最小功能，并且如果能够获得可变引用，则可以使用其他方法，您可以使用类型参数将其拆分：

trait Foo {
    fn readonly(&self) -> i32;
    fn modify(&mut self, val: i32);
}

struct FooWrapper<T> {
    foo: T,
}

impl <'a> FooWrapper<&'a Foo> {
    fn readonly(&self) -> i32 {
        self.foo.readonly()
    }
}

impl <'a> FooWrapper<&'a mut Foo> {
    fn modify(&mut self, val: i32) {
        self.foo.modify(val); //
    }
}

现在，您可以将类型参数提供为&mut Foo或&Foo，具体取决于您拥有的内容。

有什么方法可以避免重复的代码在结构中的mut而不是mut引用？

1 个答案: