Rust

Rustで動的ポリモーフィズムのようなことをしてみる（その2）

前回やってみたのは、トレイトを1つ親に持って複数の構造体を作り、そのすべてにオーバーライドしたい関数もしたくない関数もimplし、すべてのインスタンスをトレイト型にキャストしてしまおうという方法だった。
ただこの方法だと構造体をトレイト型にキャストするのでフィールドにアクセスできなくなってしまう。（トレイトにはフィールドが無いので当然そうなる）
ただ、フィールドそのものが構造体から消えてしまうわけではなく、implしたメソッドからはアクセスできるので、Publicにしたいフィールドにアクセサメソッドを追加すればなんとかなる。
フィールドをCellでラップすれば自動的にアクセサメソッドが追加されるのだが、トレイト型にキャストした時点でCellごと見えなくなるので、当然アクセサメソッドも呼び出せない。
しかたないのでアクセサメソッドを自力で書くしかない。
すべて同じフィールド名のアクセサメソッドであっても、それをトレイトに書くと「そんなフィールド無いよ」と怒られてしまうので、面倒だがすべての構造体に対して書く羽目に。（どんな構造体にimplされるのか分からないからか、トレイトにデフォルト実装したメソッドからはselfのフィールドにアクセスできないらしい）
なんか初期のObjective-CとかRubyの自作クラスみたいな感じになってしまったが・・。
さらに構造体のフィールドにアクセスする処理もトレイトに書けないわけだが、ここを共通化するには普通の関数にして、トレイト型にキャストした構造体を受け取ればいい。
結果、Rustらしさがなくなり、格好は非常に悪い。
こういうことがしたいなら素直にオブジェクト指向型言語を使うのが吉だ。（結論）

trait ShipT {
    fn x(&mut self) -> i32;
    fn set_x(&mut self, n: i32);
    fn fire(&self);
}

struct Ship {
    x: i32
}
impl ShipT for Ship {
    fn x(&mut self) -> i32 {
        self.x
    }
    fn set_x(&mut self, n: i32) {
        self.x = n;
    }
    fn fire(&self) {
        println!("fire!");
    }
}

struct SuperShip {
    x: i32
}
impl ShipT for SuperShip {
    fn x(&mut self) -> i32 {
        self.x
    }
    fn set_x(&mut self, n: i32) {
        self.x = n;
    }
    fn fire(&self) {
        println!("fire!fire!");
    }
}

struct HyperShip {
    x: i32
}
impl ShipT for HyperShip {
    fn x(&mut self) -> i32 {
        self.x
    }
    fn set_x(&mut self, n: i32) {
        self.x = n;
    }
    fn fire(&self) {
        println!("fire!fire!fire!");
    }
}

fn move_ship(ship: &mut Box<dyn ShipT>) {
    for _i in 0..5 {
        let mut x = ship.x();
        println!("moving..{}", x);
        x += 1;
        ship.set_x(x);
    }
}

fn main() {
    let mut e = Box::new(Ship{x: 0}) as Box<dyn ShipT>;
    move_ship(&mut e);
    e.fire();
    e = Box::new(SuperShip{x: e.x()}) as Box<dyn ShipT>;
    move_ship(&mut e);
    e.fire();
    e = Box::new(HyperShip{x: e.x()}) as Box<dyn ShipT>;
    move_ship(&mut e);
    e.fire();
}

[ 戻る ]