Rust と C++ のポリモーフィズムを探求：メンタルモデルの変革

Rust への挑戦は、達成感と混乱が共存する特権的な体験です。現在は書籍（『The Rust Programming Language』および Mara Bos 氏の著作）からの学習を経て、ついに自分の手でコードを読み解くことに熱意を感じています。

当初は C++ との対応関係を探ろうとしていましたが、やがて**「新しい言語を理解しようと既存言語との 1:1 の対応を見出そうとすることは罠」**という教訓を得ました。Rust を単なる「シンタックスが違うだけの C++」と扱うことは、その革新性を無意味にします。しかし、「なぜそう動くのか」を探求し、メモリ内での実際の変化を理解することに意義があります。

序論：本題の核心

複数の図形（円、四角形など）に対して

draw()

C++ のアプローチ比較

1. バーチャル関数（ランタイムポリモーフィズム）

   • オブジェクト内部に vtable ポインターを格納し、自動的に関数を解決します。

   std::vector<Shape*> shapes = { new Circle(), new Square() };
   for (auto* s : shapes)
       s->draw(); // バージョン 1: ポインタ配列による動的ディスパッチ
   

2. CRTP（コンパイル時ポリモーフィズム）

   • Curiously Recurring Template Pattern

     です。vtable は存在せず、コンパイル時に解決されます。
   • 代償としてコードが冗長になり、可読性が犠牲になります。

   template<typename Derived>
   struct Shape {
       void draw() {
           static_cast<Derived*>(this)->draw(); // コンパイル時解決
       }
   };
   

Rust の立ち位置

Rust には CRTP に相当する非常に直感的な機能があります。それが**「モノルフィゼーション（Monomorphization）」**です。まずはこのアプローチからメンタルモデルを構築しましょう。

スタティック・ディスパッチ（Static Dispatch）

ジェネリクスによるスタティック・ディスパッチは、CRTP と同様の結果（コンパイル時解決）を達成します。ランタイムコストはゼロですが、型の情報はコンパイル時に決まっている必要があります。

実装例

trait Draw {
    fn draw(&self) -> &str;
}

struct Circle;
struct Square;

impl Draw for Circle {
    fn draw(&self) -> &str { "Drawing a circle" }
}

impl Draw for Square {
    fn draw(&self) -> &str { "Drawing a square" }
}

fn draw_shape<T: Draw>(shape: T) {
    println!("{}", shape.draw());
}

fn main() {
    let circle = Circle;
    let square = Square;
    draw_shape(circle); // 内部では draw_shape::<Circle> が生成される
    draw_shape(square); // 内部では draw_shape::<Square> が生成される
}

C++ との哲学的な違い

• C++: 制約は暗黙的。テンプレートは

  .draw()

  メソッドを持つ「任意の型」を受け入れます。
• Rust: 契約は明示的。

  Square

  が

  Draw

  トリートを実装することを明確に宣言します。

サイドクエスト：Rust のゼロサイズ型（ZST）

C++ では、オブジェクトはたとえ空であっても少なくとも 1 バイトのサイズを持つことが義務付けられています。これは「自然の法則」のように思えますが、Rust はこれを破ります。

println!("{}", std::mem::size_of::<Circle>()); // 出力: 0
println!("{}", std::mem::size_of::<Square>()); // 出力: 0

メモリ内でのアイデンティティの扱い方

C++ では

&obj1 == &obj2

リリースビルドではアドレスが衝突することもありますが、コンパイラは「アイデンティティを追跡する必要がある」という保証を持っていません。Rust の哲学は**「所有権を通じてアイデンティティを追跡する」**というものです。

ダイナミック・ディスパッチ（Dynamic Dispatch）

スタティック・ディスパッチの限界（混ざった型を 1 つのコンテナに格納できないこと）を突破するために、

dyn Trait

メモリ構造の変化

fn draw_shape(shape: &dyn Draw) { // <T: Draw> の代わりに &dyn Draw
    println!("{}", shape.draw());
}

サイズを確認すると以下のように変化します：

&Circle

&dyn Draw

&dyn Draw

// unsafe ブロックが必要な理由：コンパイラがバイトごとのコピーを保証できないため
fn inspect(shape: &dyn Draw) {
    let (data_ptr, vtable_ptr) = unsafe {
        std::mem::transmute::<&dyn Draw, (usize, usize)>(shape)
    };
}

コンテナへの格納（Vec の例）

Vec<T>

解決策:

Box<dyn Draw>

let shapes: Vec<Box<dyn Draw>> = vec![
    Box::new(Circle),
    Box::new(Square),
];

• 構造:

  [data_ptr | vtable_ptr]

  の配列として格納されます。
• C++ との違い: C++ ではクラスレベルでディスパッチ方式が決まりますが、Rust では**呼出地点（Call Site）**での参照タイプによって決定されます。

空の糸のアナロジー: Rust はあなたのメンタルモデルに対して、空中に逆さまになるような「感覚の書き換え」を要求します。

各 (Type, Trait) ペアに 1 つの vtable

複数のトリートを組み合わせた場合の構造も確認します。

impl Fly for Duck { ... }
impl Swim for Duck { ... }

同じ

Duck

• データポインタ: 同じ (

  0x...58df

  )
• vtable ポインタ: 異なる (

  0x...ea48

  vs

  0x...ea68

  )

これはC++ と決定的に異なります。C++ では vtable はオブジェクト内部に埋め込まれていますが、Rust では vtable は外部の静的データとして存在します。Duck が泳ぐか飛ぶかを問わず、

Duck

オブジェクト安全性：すべてのトリートが dyn ではない

限界についても理解しておく必要があります。Rust のすべてのトリートが

dyn Trait

ルールの制限点

1. メソッドが

   Self

   を返してはいけない
   • 例：

     trait Clone { fn clone(&self) -> Self; }

   • 理由：

     Self

     は実装側（Circle など）の型を指すため、vtable 経由では呼び出し元の具体的な型とメモリ割り当て先が不明確になります。C++ ではポインタを通じて解決するためこの問題がありません。

2. メソッドがジェネリックパラメータを持てない

   • 例：

     fn serialize<T>(&self, output: &mut T)

   • 理由：あらゆる

     T

     に対して別々の vtable エントリを生成する必要があります（実質的に無限）。C++ でも同様の問題があり、回避法はプロダクションコードでは推奨されません。

まとめ

シンプルなお題から始めて、Rust の核心を理解しました。

• スタティック・ディスパッチ（モノルフィゼーション）

  • C++ の CRTP に相当します。コンパイル時解決でランタイムコストゼロですが、コードサイズ増大の欠点があります。
  • Rust ではこれがネイティブ機能として提供されています。

• ダイナミック・ディスパッチ（

  dyn Trait

  ）
  • C++ のバーチャル関数に相当します。vtable を使用します。
  • C++ との違い: C++ はインスタンスごとに常にオーバーヘッドがありますが、Rust は

    &dyn Trait

    や

    Box<dyn Trait>

    を使用する際のみ追加的なポインタ（ワイドポインタ）が発生します。

• ゼロサイズ型（ZST）

  • C++ では最低 1 バイトの確保が必要ですが、Rust は所有権を追跡するため 0 バイトで OK です。

「C++ を使っている時の常識」は Rust で必ずしも通用しないことに気づいたでしょうか？これは良いことです。メンタルモデルを更新し、Rust の革新性を味わいましょう。