有没有一种惯用的方法来实现组件模式？

Question

基本上，对象（结构）是通过组合不同的组件来构造的。每个具体组件都很容易被与接口匹配的另一个组件交换（我猜是特征）。

我目前正在尝试使用一些特征来实现，这让我陷入了一些错误，并让我开始思考这是否是 Rust 中的常见做法。

// usage example
fn main() {
    let obj = MainObject::new(Component1::new(), Component2::new(), Component3());
    // Where each component is a type(struct) with some well predefined methods.
}

这背后的主要思想是实现游戏中常用的组件模式。基本上，游戏将包含许多不同的对象，行为和包含的数据略有不同。没有一个大的类层次结构，对象是由标准组件组成的，更完整的例子是。

pub struct Container
{
   input: InputHandlerComponent, // Probably a trait
   physics: PhysicsComponent,  // Probably a trait
   renderer: RendererCompoent // Probably a trait
}

impl Container {
  fn new(p: PhysicsComponent, i: InputComponent, r: RenderComponent) -> Container {
    Container {input: i, physics: p, renderer: r}
 }
}

struct ConcretePhysicsComponent;
impl PhysicsComponent for ConcretePhysicsComponent
{
  // ...
}

struct ConcreteInputComponent;
impl InputComponent for ConcreteInputComponent
{
  // ...
}

struct ConcreteRendererComponent;
impl RendererComponent for ConcreteRendererComponent
{
  // ...
}

struct AnotherConcreteRendererComponent;
impl RendererComponent for AnotherConcreteRendererComponent
{
  // ...
}

// usage example
fn main() {
    let obj = Container::new(ConcreteInputComponent::new(), ConcretePhysicsComponent::new(), ConcreteRendererComponent::new());
    // Where each component is a type(struct) with some well predefined methods.

    // This is a slightly modified version of this object, with changed rendering behaviour
    let obj2 = Container::new(ConcreteInputComponent::new(), ConcretePhysicsComponent::new(), AnotherConcreteRendererComponent::new());    }

Answer 1

听起来你只是在问特质，该特质的多个具体实现，以及一个将自身限制为实现该特质的类型的集合器对象。（可选）容器可以通过将特征委托给内部对象来实现该特征。

trait Health {
    fn life(&self) -> u8;
    fn hit_for(&mut self, lost_life: u8);
}

#[derive(Debug, Copy, Clone)]
struct WimpyHealth(u8);
impl Health for WimpyHealth {
    fn life(&self) -> u8 { self.0 }
    fn hit_for(&mut self, lost_life: u8) { self.0 -= lost_life * 2; }
}

#[derive(Debug, Copy, Clone)]
struct BuffHealth(u8);
impl Health for BuffHealth {
    fn life(&self) -> u8 { self.0 }
    fn hit_for(&mut self, lost_life: u8) { self.0 -= lost_life / 2; }
}

#[derive(Debug, Copy, Clone)]
struct Player<H> {
    health: H,
}

impl<H> Health for Player<H>
    where H: Health
{
    fn life(&self) -> u8 { self.health.life() }
    fn hit_for(&mut self, lost_life: u8) { self.health.hit_for(lost_life) }
}

fn main() {
    let mut player_one = Player { health: WimpyHealth(128) };
    let mut player_two = Player { health: BuffHealth(128) };

    player_one.hit_for(12);
    player_two.hit_for(12);

    println!("{:?}", player_one);
    println!("{:?}", player_two);
}

如果不使用盒装值，则不可能有此类玩家的数组

没错。数组或向量(或者任何泛型类型)需要都是相同的类型。这对于数组/向量尤其重要，因为它们的内存布局是连续的，每一项都需要有固定的间隔。

如果你被允许使用不同类型的人，那么你可以有一个玩家的生命值为1字节，而另一个玩家的生命值为2个字节。然后，所有偏移量都不正确。

您可以为框实现健康特性

impl<H: ?Sized> Health for Box<H>
    where H: Health
{
    fn life(&self) -> u8 { (**self).life() }
    fn hit_for(&mut self, lost_life: u8) { (**self).hit_for(lost_life) }
}

fn main() {
    let mut players = vec![
        Player { health: Box::new(WimpyHealth(128)) as Box<Health> },
        Player { health: Box::new(BuffHealth(128)) as Box<Health> }
    ];

    for player in players.iter_mut() {
        player.hit_for(42);
    }

    println!("{:?}", players[0].life());
    println!("{:?}", players[1].life());
}