鏽病性狀狀態

Question

我會用這個怪物「怪物」代碼Rust for Rubyist開始：

trait Monster { 
    fn attack(&self); 
    fn new() -> Self; 
} 

struct IndustrialRaverMonkey { 
    life: int, 
    strength: int, 
    charisma: int, 
    weapon: int, 
} 

struct DwarvenAngel { 
    life: int, 
    strength: int, 
    charisma: int, 
    weapon: int, 
} ... 
impl Monster for IndustrialRaverMonkey { ... 
impl Monster for DwarvenAngel { ... 

我擔心重複的代碼。在Java中，我將創建一個接口，該接口用所有參數定義attack方法和基類（life,strength,charisma,weapon）。我會用抽象類在C++中做同樣的事情。 我可以找到一些醜陋而不直觀的方法來解決這個問題，但有沒有減少代碼的好方法？我的意思是，保持它的可擴展性和可讀性。

Answer 1

你會認爲這是一個可接受的解決方案嗎？

trait Actor { 
    fn attack(&self); 
} 

enum MonsterId { 
    IndustrialRaverMonkey, 
    DwarvenAngel 
} 

struct Monster { 
    life: int, 
    strength: int 
} 

impl Monster { 
    fn new(id: MonsterId) -> Monster { 
     match id { 
      IndustrialRaverMonkey => 
      Monster { life: 12, strength: 8 }, 

      DwarvenAngel => 
      Monster { life: 18, strength: 12 } 
     } 
    } 
} 


impl Actor for Monster { 
    fn attack(&self) {} 
} 

更新了一個更好的例子。

Answer 2

另一種方法，這有利於組成，並從其中如果需要的話更容易發散的實現（例如，Characteristics爲DwarvenAngel需要額外的字段）：

trait Monster { 
    fn attack(&self); 
} 

struct Characteristics { 
    life: int, 
    strength: int, 
    charisma: int, 
    weapon: int, 
} 

struct IndustrialRaverMonkey { 
    characteristics: Characteristics 
} 

struct DwarvenAngel { 
    characteristics: Characteristics 
} 

fn same_attack(c: Characteristics) { 
    fail!("not implemented") 
} 

impl Monster for IndustrialRaverMonkey { 
    fn attack(&self) { 
     same_attack(self.characteristics) 
    } 
} 

impl Monster for DwarvenAngel { 
    fn attack(&self) { 
     same_attack(self.characteristics) 
    } 
} 

或者，你可以有一個枚舉代表你怪物類型，與AB的答案非常相似：

trait Monster { 
    fn attack(&self); 
} 

struct Characteristics { 
    life: int, 
    strength: int, 
    charisma: int, 
    weapon: int, 
} 

enum Monsters { 
    IndustrialRaverMonkey(Characteristics), 
    DwarvenAngel(Characteristics), 
} 

fn same_attack(_: &Characteristics) { 
    fail!("not implemented") 
} 

impl Monster for Monsters { 
    fn attack(&self) { 
     match *self { 
      IndustrialRaverMonkey(ref c) => same_attack(c), 
      DwarvenAngel(ref c)   => same_attack(c) 
     } 
    } 
}