如何在数组中存储类型？

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函数可以返回关联的类型，但这也不能很好地与动态分派配合，因此我返回一个类型erased 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），因为我们没有任何东西可以存储在那里。

主要功能也非常简单。我已经将你的循环切换为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();
    }
}

这按预期工作并打印（游乐场）：

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