2

我是 Rust 的新手。我的背景是Java。我正在尝试解决以下问题。

  1. 我有一个trait Fuel为struct Dieseland实现的struct Gas。
  2. 我也有一个trait Vehicle泛型Fuel类型参数。Vehicle 用于struct Car<F: Fuel>和struct Bus<F: Fuel>。

最后，我想将对可能的异构特征对象的引用放在这样的对象中Vec：

let diesel_car = Car { fuel: Diesel {} };
let gas_car = Car { fuel: Gas {} };
let diesel_bus = Bus { fuel: Diesel {} };
let gas_bus = Bus { fuel: Gas {} };

let garage = vec![
    &diesel_car,
    &gas_car,
    &diesel_bus,
    &gas_bus
];

但我得到这个编译错误：

error[E0308]: mismatched types
  --> src/main.rs:63:9
   |
63 |         &gas_car,
   |         ^^^^^^^^ expected struct `Diesel`, found struct `Gas`
   |
   = note:   expected type `&Car<Diesel>`
           found reference `&Car<Gas>`

这个 Vec 中引用的通用类型应该是什么？它猜它应该是类似的东西Vec<&dyn Vehicle>。但是这个变体也不能编译，因为它想提前知道泛型类型参数Vehicle。在 Java 中我只会写List<Vehicle<?>. Rust 中是否有类似的东西？

整个示例可在操场上找到。

PS我显然可以从中删除一个通用参数Vehicle并将其替换为Box<dyn Fuel>，但我想通过动态调度来最小化位置。

4

2 回答 2

1

但是这个变体也不能编译，因为[编译器]想提前知道泛型类型参数Vehicle。

我认为您在这里混淆了静态调度和动态调度。我认为你也混淆了你要求编译器做什么和你期望它做什么。听起来很明显你想要动态调度，但是你试图使用泛型来实现它，这是不可能的，因为泛型是一个纯粹的编译时抽象，并且总是会产生静态调度代码。“泛型”在运行时不存在，也不存在于最终的二进制文件中。如果您想要“运行时泛型”，那就是特征对象和动态分派的用途。

在 Java 中我只会写List<Vehicle<?>>. Rust 中是否有类似的东西？

是的，用trait 对象替换F: Fuel泛型类型参数。dyn Fuel

PS我显然可以从中删除一个通用参数Vehicle并将其替换为Box<dyn Fuel>，但我想通过动态调度来最小化位置。

但是您刚刚问到如何在 Rust 中实现 Java 等价物，而这正是 Java 解决这个问题的方式：通过使用动态调度。你不能一边吃蛋糕一边吃。如果你想要静态调度的速度，那就意味着还要接受静态调度的约束。如果这些约束对您的程序来说过于严格，那么您应该使用特征对象和动态调度。

Rust 的枚举可能是你能得到的最接近你想要的东西。它们是泛型和特征对象之间的一个很好的折衷方案，为您提供（几乎）前者的速度，同时为您提供后者的灵活性。这是重构为使用枚举的示例：

enum Fuel {
    Diesel,
    Gas,
}

impl Fuel {
    fn efficiency(&self) -> f64 {
        match self {
            Fuel::Diesel => 0.9,
            Fuel::Gas => 0.8,
        }
    }
}

enum Vehicle {
    Car(Fuel),
    Bus(Fuel)
}

impl Vehicle {
    fn mass(&self) -> f64 {
        match self {
            Vehicle::Car(_) => 1000.0,
            Vehicle::Bus(_) => 5000.0,
        }
    }
}

fn main() {
    let diesel_car = Vehicle::Car(Fuel::Diesel);
    let gas_car = Vehicle::Car(Fuel::Gas);
    let diesel_bus = Vehicle::Bus(Fuel::Diesel);
    let gas_bus = Vehicle::Bus(Fuel::Gas);

    let garage = vec![
        &diesel_car,
        &gas_car,
        &diesel_bus,
        &gas_bus
    ];
}

操场

于 2021-02-07T13:14:54.790 回答
0

不可能将不同的类型放在同一个向量中。但是，使用枚举，您可以在不需要不同类型的情况下获得您正在寻找的功能。

由于您有 2 种燃料，它们的枚举将如下所示：

pub enum Fuel {
    Diesel,
    Gas,
}

然后添加一个函数efficiency来返回每个燃料变体的效率：

impl Fuel {
    fn efficiency(&self) -> f64 {
        match self {
            Fuel::Diesel => 0.9,
            Fuel::Gas => 0.8,
        }
    }
}

您现在有 2 种相同类型的燃料。

在对车辆执行相同操作后（您也有 2 个变体），您可以将各种组合添加到同一个向量中。

这是一个完整的例子。

你可以在这里阅读枚举。

于 2021-02-07T13:01:57.430 回答