rust - 如何将类型存储在数组中？

Question

我想创建一个包含结构类型(非实例化)的数组，所有结构类型都实现相同的特征。我试过这样做:

trait TraitA {
    fn new(number: i16) -> Self;
    fn get_name() -> &'static str;
}

struct StructA {
    bar: u8
}
struct StructB {
    foo: i16
}

impl TraitA for StructA {
    fn new(number: i16) -> Self {
        StructA { bar: number as u8 }
    }
    fn get_name() -> &'static str
    { "StructA" }
}
impl TraitA for StructB {
    fn new(number: i16) -> Self {
        StructB { foo: number }
    }
    fn get_name() -> &'static str
    { "StructB" }
}

fn main() {
    let struct_array = [StructA, StructB];

    for i in 0..struct_array.len() {
        println!("{}", struct_array[i]::get_name());
        struct_array[i]::new(i);
    }
}

编译器需要一个实际值，而不是类型。

在 Python 中，我会这样做:

class ClassA:
    def __init__(self, number):
        self.bar = number
    def get_name():
        return "ClassA"
class ClassB:
    def __init__(self, number):
        self.foo = number
    def get_name():
        return "ClassB"

if __name__ == "__main__":
    class_array = [ClassA, ClassB]
    for i in range(2):    
        print(class_array[i].get_name())
        class_array[i](i)

我怎样才能做到这一点？

Answer 1

在 Python 中，类也是对象和可调用对象，调用它们可以创建该类型的新对象。

在 Rust 中，正如 SvenMarnach 上面评论的那样，类型不是对象；它们只存在于编译时，在运行程序中没有表现。

要执行您想要的操作，您必须创建一个模仿 Python 类类型 的类型。某种工厂模式，自然会成为一种特质。我假设您想对这些 TraitA 做些什么对象，而不是创建它们，所以让我们添加一些有用的东西并将构建的东西移动到另一个特征:

trait TraitA {
    fn do_something(&self);
}
trait FactoryA {
    fn new(&self, number: i16) -> Box<dyn TraitA>;
    fn get_name(&self) -> &'static str;
}

请注意，我添加了一个 &self每个函数的参数。这是必要的，因为我们稍后要调用动态调度，而在 Rust 中，没有 self 就无法进行动态调度。 .但是这个特征代表你的 Python 类，所以这个成员函数类似于 Python 类方法。

还有 new函数可以返回一个关联类型，但这也不能很好地与动态调度一起使用，所以我返回一个已删除的类型 Box<dyn TraitA> .

现在，实现几个类非常无聊:

struct StructA {
    bar: u8
}
struct StructB {
    foo: i16
}

impl TraitA for StructA {
    fn do_something(&self) {
        println!("I'm an A({})", self.bar);
    }
}
impl TraitA for StructB {
    fn do_something(&self) {
        println!("I'm a B({})", self.foo);
    }
}

实现工厂更有趣:

struct BuilderA;

struct BuilderB;

impl FactoryA for BuilderA {
    fn new(&self, number: i16) -> Box<dyn TraitA> {
        Box::new(StructA { bar: number as u8 })
    }
    fn get_name(&self) -> &'static str
    { "StructA" }
}
impl FactoryA for BuilderB {
    fn new(&self, number: i16) -> Box<dyn TraitA> {
        Box::new(StructB { foo: number })
    }
    fn get_name(&self) -> &'static str
    { "StructB" }
}

我们为构建器使用零大小类型 (ZST)，因为我们没有任何东西可以存储在那里。

main 函数也很简单。我已将您的循环切换为 Iterator::enumerate只是为了好玩:

fn main() {
    let struct_array: Vec<Box<dyn FactoryA>> = vec![
        Box::new(BuilderA),
        Box::new(BuilderB),
    ];

    for (i, b) in struct_array.iter().enumerate() {
        println!("{}", b.get_name());
        let a = b.new(i as i16);
        a.do_something();
    }
}

这按预期工作并打印(playground):

StructA
I'm an A(0)
StructB
I'm a B(1)