Day 013 — デフォルト実装とトレイトオブジェクト — 静的/動的ディスパッチ

📚 背景知識（読んでから問題へ）

トレイトのメソッドは、宣言だけでなくデフォルト実装（default implementation）を持てます。実装側は何もしなければデフォルトの挙動を借り、必要な型だけそのメソッドをオーバーライドできます。

📋 コピーtrait Greet {
    fn name(&self) -> &str;

    // デフォルト実装: name() を使って共通の挨拶文を組み立てる
    fn greet(&self) -> String {
        format!("こんにちは、{}です", self.name())
    }
}

これはトレイトの「共通の振る舞いを定義する」という役割を一歩進め、共通ロジックの重複を型ごとに書かせずに済ませる仕組みです。

もう一つ、Day012まではfn largest<T: PartialOrd>(...)のようなジェネリクスを使ってきました。これは呼び出し箇所ごとにコンパイラがTを具体的な型に置き換えたコードを生成する静的ディスパッチ（static dispatch）で、この置き換え処理をモノモーフィゼーション（monomorphization）と呼びます。関数呼び出しは通常の直接呼び出しになるため実行時コストがゼロですが、代償として「呼び出し箇所ごとに型が1つに固定される」「型の数だけコードが複製されバイナリサイズが増える」という制約があります。

これに対し、dyn Trait（トレイトオブジェクト）を使うと動的ディスパッチ（dynamic dispatch）になります。実行時にvtable（仮想関数テーブル）経由でメソッドを呼び出すため、Vec<Box<dyn Shape>>のように異なる具象型を1つのコレクションに混在させられます。実行時に一段階の間接呼び出しが挟まる分わずかなコストがありますが、柔軟性が上がります。

📋 コピー// 静的ディスパッチ: T は呼び出し箇所ごとに単一の具象型に固定される
fn print_static<T: Greet>(x: &T) { println!("{}", x.greet()); }

// 動的ディスパッチ: 異なる具象型を同じ関数・同じコレクションで扱える
fn print_dynamic(x: &dyn Greet) { println!("{}", x.greet()); }

📝 問題

図形を表すトレイトShapeを設計し、静的ディスパッチと動的ディスパッチの両方を体験する実装課題です。

要件1: Shapeトレイトの定義

📋 コピーtrait Shape {
    fn area(&self) -> f64;
    fn name(&self) -> &str;

    // デフォルト実装を用意する（area と name を使って組み立てる）
    fn describe(&self) -> String {
        // ここに "{name}の面積は{area:.2}です" 形式のデフォルト実装を書く
    }
}

• area(&self) -> f64とname(&self) -> &strはトレイト側では実装を持たない（実装側が必ず定義する）
• describe(&self) -> Stringはarea()とname()を使い、"{name}の面積は{area:.2}です"という文字列を返すデフォルト実装を持たせる（{area:.2}は小数点以下2桁）

要件2: 2つの図形型を実装する

• struct Circle { radius: f64 }: area()はπ × radius × radius（std::f64::consts::PIを使う）、name()は"円"を返す。describe()をオーバーライドし、"{name}(半径{radius:.1}) の面積は{area:.2}です [カスタム実装]"という独自フォーマットにする
• struct Rectangle { width: f64, height: f64 }: area()はwidth × height、name()は"長方形"を返す。describe()はオーバーライドせず、デフォルト実装をそのまま使う

要件3: 静的ディスパッチ関数と動的ディスパッチ関数

📋 コピー// 静的ディスパッチ: 同じ具象型のスライスのみを受け付ける
fn total_area_static<T: Shape>(shapes: &[T]) -> f64 {
    // 実装する
}

// 動的ディスパッチ: 異なる具象型を混在させたコレクションを受け付ける
fn total_area_dynamic(shapes: &[Box<dyn Shape>]) -> f64 {
    // 実装する
}

• どちらも各図形のarea()の合計を返す
• total_area_staticはVec<Circle>のような単一の型のスライスにのみ使える（Tは呼び出し箇所ごとに1つの型に固定されるため）
• total_area_dynamicはVec<Box<dyn Shape>>のように異なる型が混在したスライスに使える

検証課題

main関数と#[cfg(test)]のテストで、以下をすべて検証してください。

1. Rectangleのdescribe()がデフォルト実装どおりの文字列を返す
2. Circleのdescribe()がオーバーライドしたカスタム文字列を返す（"[カスタム実装]"を含む）
3. total_area_staticにVec<Circle>を渡し、合計面積が正しく計算される
4. total_area_dynamicにVec<Box<dyn Shape>>（CircleとRectangle混在）を渡し、合計面積が正しく計算される
5. （発展・任意）total_area_staticにCircleとRectangleを混在させて渡そうとするとコンパイルエラーになることをコメントで示す（実際に混在コードを書く必要はない。なぜダメなのかをコメントで説明できれば良い）

🔍 ヒント（段階的開示）

📋 コピーtrait Shape {
    fn area(&self) -> f64;
    fn name(&self) -> &str;

    fn describe(&self) -> String {
        format!("{}の面積は{:.2}です", self.name(), self.area())
    }
}

struct Circle {
    radius: f64,
}

impl Shape for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.radius * self.radius
    }
    fn name(&self) -> &str {
        "円"
    }
    fn describe(&self) -> String {
        // ここでデフォルトとは違うフォーマットを組み立てる
    }
}

struct Rectangle {
    width: f64,
    height: f64,
}

impl Shape for Rectangle {
    fn area(&self) -> f64 {
        self.width * self.height
    }
    fn name(&self) -> &str {
        "長方形"
    }
    // describe は書かない → デフォルトが使われる
}

fn total_area_static<T: Shape>(shapes: &[T]) -> f64 {
    // shapes.iter().map(...).sum()
}

fn total_area_dynamic(shapes: &[Box<dyn Shape>]) -> f64 {
    // shapes.iter().map(...).sum()
}

✅ 模範解答

📋 コピーtrait Shape {
    fn area(&self) -> f64;
    fn name(&self) -> &str;

    // デフォルト実装: area() と name() を使って共通フォーマットの文字列を組み立てる
    fn describe(&self) -> String {
        format!("{}の面積は{:.2}です", self.name(), self.area())
    }
}

struct Circle {
    radius: f64,
}

impl Shape for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.radius * self.radius
    }
    fn name(&self) -> &str {
        "円"
    }
    // デフォルト実装をオーバーライドして独自フォーマットにする
    fn describe(&self) -> String {
        format!(
            "{}(半径{:.1}) の面積は{:.2}です [カスタム実装]",
            self.name(),
            self.radius,
            self.area()
        )
    }
}

struct Rectangle {
    width: f64,
    height: f64,
}

impl Shape for Rectangle {
    fn area(&self) -> f64 {
        self.width * self.height
    }
    fn name(&self) -> &str {
        "長方形"
    }
    // describe は書かない → トレイトのデフォルト実装がそのまま使われる
}

// 静的ディスパッチ: T は呼び出し箇所ごとに単一の具象型に固定される（モノモーフィゼーション）
// メリット: 実行時コストゼロ（直接呼び出しにインライン化されうる）
// 制約: Circle と Rectangle を混ぜた Vec は渡せない（下の #[test] コメント参照）
fn total_area_static<T: Shape>(shapes: &[T]) -> f64 {
    shapes.iter().map(|s| s.area()).sum()
}

// 動的ディスパッチ: vtable 経由の呼び出しになる代わりに、異なる具象型を混在できる
fn total_area_dynamic(shapes: &[Box<dyn Shape>]) -> f64 {
    shapes.iter().map(|s| s.area()).sum()
}

fn main() {
    let circle = Circle { radius: 2.0 };
    let rectangle = Rectangle { width: 3.0, height: 4.0 };

    println!("{}", circle.describe());
    println!("{}", rectangle.describe());

    // 静的ディスパッチ: Circle だけのスライス
    let circles = vec![Circle { radius: 1.0 }, Circle { radius: 2.0 }];
    println!(
        "同種図形の合計面積(静的ディスパッチ): {:.2}",
        total_area_static(&circles)
    );

    // 動的ディスパッチ: Circle と Rectangle が混在したコレクション
    let shapes: Vec<Box<dyn Shape>> = vec![
        Box::new(Circle { radius: 2.0 }),
        Box::new(Rectangle { width: 3.0, height: 4.0 }),
    ];
    println!(
        "異種図形の合計面積(動的ディスパッチ): {:.2}",
        total_area_dynamic(&shapes)
    );
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn rectangle_uses_default_describe() {
        let r = Rectangle { width: 3.0, height: 4.0 };
        assert_eq!(r.describe(), "長方形の面積は12.00です");
    }

    #[test]
    fn circle_overrides_describe() {
        let c = Circle { radius: 2.0 };
        assert!(c.describe().contains("カスタム実装"));
    }

    #[test]
    fn total_area_static_sums_same_type() {
        let circles = vec![Circle { radius: 1.0 }, Circle { radius: 2.0 }];
        let expected =
            std::f64::consts::PI * 1.0 * 1.0 + std::f64::consts::PI * 2.0 * 2.0;
        assert!((total_area_static(&circles) - expected).abs() < 1e-9);
    }

    #[test]
    fn total_area_dynamic_sums_mixed_types() {
        let shapes: Vec<Box<dyn Shape>> = vec![
            Box::new(Circle { radius: 2.0 }),
            Box::new(Rectangle { width: 3.0, height: 4.0 }),
        ];
        let expected = std::f64::consts::PI * 2.0 * 2.0 + 12.0;
        assert!((total_area_dynamic(&shapes) - expected).abs() < 1e-9);
    }

    // 発展課題(要件3-5): 次のコードはコンパイルできない。
    //
    //   let mixed = vec![Circle { radius: 1.0 }, Rectangle { width: 1.0, height: 1.0 }];
    //   total_area_static(&mixed);
    //
    // 理由: total_area_static<T: Shape>(shapes: &[T]) の T は「呼び出し箇所ごとに
    // 1つの具象型」に固定される（モノモーフィゼーション）。vec![...] マクロも
    // 「全要素が同じ型であること」を要求するため、Circle と Rectangle という
    // 異なる型を1つの Vec<T> に入れることそのものが最初の時点でエラーになる。
    // 混在させたい場合は Vec<Box<dyn Shape>> にして total_area_dynamic を使う。
}

$ cargo run
円(半径2.0) の面積は12.57です [カスタム実装]
長方形の面積は12.00です
同種図形の合計面積(静的ディスパッチ): 15.71
異種図形の合計面積(動的ディスパッチ): 24.57

$ cargo test
running 4 tests
test tests::rectangle_uses_default_describe ... ok
test tests::circle_overrides_describe ... ok
test tests::total_area_static_sums_same_type ... ok
test tests::total_area_dynamic_sums_mixed_types ... ok

test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

🪜 Step-by-Step 解説

📋 コピーfn total_area_static<T: Shape>(shapes: &[T]) -> f64 {
    shapes.iter().map(|s| s.area()).sum()
}

📋 コピーfn total_area_dynamic(shapes: &[Box<dyn Shape>]) -> f64 {
    shapes.iter().map(|s| s.area()).sum()
}

💡 設計思想・なぜこう書くのか

🛑 コンパイルエラーが出た場合

このテーマでは、dyn Traitをポインタ（Box/&）なしで直接扱おうとしたときに典型的なエラーが出ます。例えば次のような「条件によってCircleかRectangleのどちらかを返す」関数を、うっかりdyn Shapeのまま返そうとした場合です。

📋 コピーfn make_shape(is_circle: bool) -> dyn Shape {
    if is_circle {
        Circle { radius: 1.0 }
    } else {
        Rectangle { width: 1.0, height: 1.0 }
    }
}

読み方:

• return type cannot be a trait object without pointer indirection / doesn't have a size known at compile-time: dyn Shapeという型そのものは「サイズが分からない」ため、関数の戻り値の型（スタック上に確保される必要がある）に直接使えません
• コンパイラの2つのhelpは、実際の2つの解決策をそのまま提示しています。1つはimpl Shape（静的ディスパッチ、ただし「戻り値は常に同じ具象型」という制約付き）、もう1つはBox<dyn Shape>（動的ディスパッチ、異なる具象型を条件分岐で返せる）

ちなみにhelpの1つ目に従ってimpl Shapeに変えても、今回のようにifの分岐でCircleとRectangleという異なる具象型を返そうとすると、今度は別のエラーになります。

読み方: impl Shapeは「戻り値の型は関数ごとに1つの具象型に決まる」という静的ディスパッチの制約そのものなので、分岐によって異なる具象型を返すことを許しません（ifブロックの型Circleが「期待される型」として先に確定し、elseブロックのRectangleがそれと一致しないというエラーになります）。コンパイラのhelpも的確に「Box<dyn Shape>に変えて両方の分岐をBox::newで包む」ことを提案してきます。「異なる具象型を条件によって返したい」なら、選べる道はBox<dyn Shape>（動的ディスパッチ）しかない、という事実がこの2つのエラーから浮き彫りになります。

修正方法: -> Box<dyn Shape>にして、各分岐をBox::new(...)で包む。

🌐 他言語との比較

RustとC++は「デフォルト静的・明示的に動的を選ぶ」という思想を共有する数少ない言語ペアです。GoとJavaはインターフェース/仮想メソッドが常に動的ディスパッチである代わりに、その代償（実行時コスト・vtable経由の間接呼び出し）を言語利用者が意識せずに済むよう設計されています。Rustは代償を明示的に選ばせることで、パフォーマンスが重要な箇所（ホットパス）ではジェネリクスを、柔軟性が重要な箇所（プラグイン機構など）ではdyn Traitを、コードを見ただけで判断できるようにしています。

🏆 実務での使いどころ

• デフォルト実装: Iteratorトレイトのmap/filter/foldなどはすべてデフォルト実装で、自作イテレータはnext()だけ実装すれば大量のメソッド群が無料で手に入ります。自前のトレイト設計でも「必須の最小メソッド + それを使ったデフォルトの便利メソッド」という構成は頻出パターンです
• プラグイン機構: Vec<Box<dyn Plugin>>のように動的ディスパッチを使い、実行時に読み込む処理の種類を増減できる設計（例: ロギングのバックエンドを複数種類切り替え可能にする、通知チャネルをSlack/メール/Webhookで抽象化する）は、dyn Traitの典型的な使いどころです
• パフォーマンスクリティカルな内部実装: 型が呼び出し箇所で確定しているホットパス（数値計算ライブラリの内部ループなど）では、ジェネリクスによる静的ディスパッチを選び、コンパイラの最適化（インライン化）を最大限活かします

⚠️ よくある誤解・ミス

🚀 次のステップ

• 発展: Shapeに3つ目の型（例えばTriangle）を追加し、describeをオーバーライドせずデフォルトのままにした場合と、独自メッセージにオーバーライドした場合の両方を試してみてください
• 次回予告: Day 014では演算子オーバーロード（std::ops）を扱います。Add/Mulなどの標準トレイトを自分の型に実装し、+や*のような演算子を独自の意味で使えるようにする方法を学びます

🎯 自己評価

自分の回答

気づき・メモ