问如何将具体的装箱对象转换为盒式特征对象
EN

Stack Overflow用户

提问于 2022-09-10 04:02:07

回答 1查看 100关注 0票数 0

解决这个问题肯定还有其他方法，但我只是好奇，是否有办法使下面的代码以某种方式在Rust中工作，我还不知道。

下面的代码示例(游乐场)

use std::sync::{Arc, Mutex};

trait ProvidesFoo {
    fn magic(&mut self);
}

struct Foo {
    magic_value: u32
}

impl Default for Foo {
    fn default() -> Self {
        Self {magic_value: 42}
    }
}

impl ProvidesFoo for Foo {
    fn magic(&mut self) {
        println!("ProvidesFoo magic {}", self.magic_value);
    }
}

pub type SharedFooConcrete = Arc<Mutex<Box<Foo>>>;
pub type SharedFooTraitObj = Arc<Mutex<Box<dyn ProvidesFoo + Send + Sync>>>;

struct FooProvider {
    foo_as_trait_obj: SharedFooTraitObj

}

impl FooProvider {
    fn magic_and_then_some(&mut self) {
        let mut fooguard = self.foo_as_trait_obj.lock().unwrap();
        fooguard.magic();
        println!("Additional magic");
    }
}

fn uses_shared_foo_boxed_trait_obj(foo: SharedFooTraitObj) {
    let mut foo_provider = FooProvider {
        foo_as_trait_obj: foo
    };
    foo_provider.magic_and_then_some();
}
fn uses_shared_foo_concrete(foo: SharedFooConcrete) {
    let mut fooguard = foo.lock().unwrap();
    fooguard.magic();
}

fn main() {
    let shared_foo = Arc::new(Mutex::new(Box::new(Foo::default())));
    uses_shared_foo_concrete(shared_foo.clone());
    uses_shared_foo_boxed_trait_obj(shared_foo);
}

将无法编译，出现以下错误：

error[E0308]: mismatched types
  --> fsrc-example/src/bin/test2.rs:52:37
   |
52 |     uses_shared_foo_boxed_trait_obj(shared_foo);
   |     ------------------------------- ^^^^^^^^^^ expected trait object `dyn ProvidesFoo`, found struct `Foo`
   |     |
   |     arguments to this function are incorrect
   |
   = note: expected struct `Arc<Mutex<Box<(dyn ProvidesFoo + Send + Sync + 'static)>>>`
              found struct `Arc<Mutex<Box<Foo>>>`
note: function defined here

确实有一种方法可以将一个盒式特征对象“强制转换”到它的具体类型，如所示的这里，但这基本上是相反的。我来自C++背景，所以我熟悉这种类型的API，其中派生对象可以作为基类传递。

我提到和使用的另一个可能的解决方案是有一个包装器结构，它将SharedFooTraitObject作为字段并在上面实现magic_and_then_some()操作。然后，可以传递包装器结构，并克隆库代码的Arc<Mutex>ed字段，而库代码只需要特征对象。

我只是好奇这种类型的强制/投射在锈蚀中是否可行。

好心的问候，RM

traits

rust

casting

电商音视频处理解决方案

为电商客户场景提供短视频处理、音频加密处理等场景方案，提高客户效率和用户体验

回答 1

Stack Overflow用户

发布于 2022-09-10 09:41:35

我不确定我是否正确地理解了你想要的东西；抱歉，如果我错了。

我删除了所有的包装类型，以便集中于具体类型的引用和对dyn特性的引用。

提供对具体类型的引用，其中对dyn特征的引用是由语言隐式处理的，因为所有信息都是在编译时提供的。可以提供指向适当的虚拟表的fat指针，因为具体类型是众所周知的。

另一方面，当使用dyn特性时，编译器不再知道原始类型，然后在不可能对具体类型的引用提供对dyn特征的引用的情况下。

如果我们真的想实现这一点，我们需要一些运行时检查。特性可以为此目的提供帮助。当我们下陷时，我们确定了混凝土的类型，这样我们就可以得到对这种混凝土类型的参考。

现在，当谈到Arc<Mutex<Box<Foo>>>和Arc<Mutex<Box<dyn ProvidesFoo + Send + Sync>>>时，不可能发生隐式或显式转换，因为这不仅仅是胖指针和普通指针之间的转换问题:所有权和同步在Mutex和Arc中起作用。我们不能克隆Arc并期望新的指针包含一种与原始指针不同的指针；如果我们能够构建另一个Arc，其中包含期望的指针，那么第二个Arc将完全独立于原始的指针，因此这将是一个完全不同的所有权语义。

我只是建议您在所有地方保持Arc<Mutex<Box<dyn ProvidesFoo + Send + Sync>>>，如果这是您的API所需要的，并且只要您需要返回一个具体的类型，您就可以获得它包含的动态引用，并使用这个示例中所示的Any解决方案。

use std::any::Any;

trait MyTrait: Any {
    fn show(&self);
    fn action(&mut self);
    fn as_any(&self) -> &dyn Any;
    fn as_any_mut(&mut self) -> &mut dyn Any;
}

struct MyStructA {
    value: i32,
}

impl MyStructA {
    fn new(value: i32) -> Self {
        Self { value }
    }
}

impl MyTrait for MyStructA {
    fn show(&self) {
        println!("value is {}", self.value);
    }
    fn action(&mut self) {
        self.value += 1;
        self.show();
    }
    fn as_any(&self) -> &dyn Any {
        self
    }
    fn as_any_mut(&mut self) -> &mut dyn Any {
        self
    }
}

struct MyStructB {
    txt: String,
}

impl MyStructB {
    fn new(txt: String) -> Self {
        Self { txt }
    }
}

impl MyTrait for MyStructB {
    fn show(&self) {
        println!("txt is {}", self.txt);
    }
    fn action(&mut self) {
        self.txt.push_str(" •");
        self.show();
    }
    fn as_any(&self) -> &dyn Any {
        self
    }
    fn as_any_mut(&mut self) -> &mut dyn Any {
        self
    }
}

fn use_impl_trait(t: &mut impl MyTrait) {
    print!("impl: ");
    t.action();
}

fn use_dyn_trait(t: &mut dyn MyTrait) {
    print!("dyn: ");
    t.action();
}

fn main() {
    {
        println!("~~~~ using concrete types ~~~~");
        let mut msa = MyStructA::new(100);
        let msa_ref = &mut msa;
        use_dyn_trait(msa_ref);
        use_impl_trait(msa_ref);
        let mut msb = MyStructB::new("xxx".to_owned());
        let msb_ref = &mut msb;
        use_dyn_trait(msb_ref);
        use_impl_trait(msb_ref);
    }
    {
        println!("~~~~ using dynamic types ~~~~");
        let mut msa = MyStructA::new(200);
        let msa_dyn_ref: &mut dyn MyTrait = &mut msa;
        use_dyn_trait(msa_dyn_ref);
        if let Some(msa_ref) =
            msa_dyn_ref.as_any_mut().downcast_mut::<MyStructA>()
        {
            use_impl_trait(msa_ref);
        }
        let mut msb = MyStructB::new("yyy".to_owned());
        let msb_dyn_ref: &mut dyn MyTrait = &mut msb;
        use_dyn_trait(msb_dyn_ref);
        if let Some(msb_ref) =
            msb_dyn_ref.as_any_mut().downcast_mut::<MyStructB>()
        {
            use_impl_trait(msb_ref);
        }
    }
}
/*
~~~~ using concrete types ~~~~
dyn: value is 101
impl: value is 102
dyn: txt is xxx •
impl: txt is xxx • •
~~~~ using dynamic types ~~~~
dyn: value is 201
impl: value is 202
dyn: txt is yyy •
impl: txt is yyy • •
*/