Day 014 — 演算子オーバーロード（std::ops） — Add実装のムーブと所有権

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

Rustでは+・-・*などの演算子は、実はstd::opsモジュールで定義されたトレイト（Add・Sub・Mulなど）への糖衣構文（syntax sugar）です。自分の型にAddトレイトを実装すれば、+演算子をその型に対して使えるようになります。

📋 コピーuse std::ops::Add;

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

impl Add for Point {
    type Output = Point; // 演算結果の型（関連型）

    fn add(self, other: Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

Addトレイトの定義は次のようになっています（標準ライブラリより抜粋）。

📋 コピーpub trait Add<Rhs = Self> {
    type Output;
    fn add(self, rhs: Rhs) -> Self::Output;
}

ここで注目すべきはfn add(self, rhs: Rhs)の両方の引数が参照ではなく値であることです。つまりa + bと書いた瞬間、aとbはadd関数にムーブ（所有権が移動）します。これは他言語の演算子オーバーロード（C++のoperator+はデフォルトでconst&を取ることが多い、Javaは演算子オーバーロード自体が存在しない等）と比べて、Rustの所有権システムがここにも一貫して適用されている例です。

i32やf64のようなCopy型であれば「ムーブ」と「コピー」が実質同じ動作になるため、この事実を意識しなくても問題は起きません。しかし、Stringやヒープ確保を伴う独自構造体のような非Copy型でこれを行うと、a + bの後にaを再度使おうとしてムーブ済みの値を使おうとするエラー（E0382）が発生します。これは実際にString + &str（標準ライブラリのimpl Add<&str> for String）でも起きる、Rustではよく知られた挙動です。

📋 コピーlet s1 = String::from("Hello, ");
let s2 = String::from("world!");
let s3 = s1 + &s2; // s1 はここでムーブされる（&s2 は借用なので s2 は生き残る）
// println!("{}", s1); // ← コンパイルエラー: s1 は既にムーブ済み

📝 問題

以下は「金額（円単位・整数）」を表すMoney型に+演算子を実装しようとしたコードです。このコードはコンパイルエラーになります。

📋 コピーuse std::ops::Add;

#[derive(Debug)]
struct Money {
    yen: i64,
}

impl Add for Money {
    type Output = Money;

    fn add(self, other: Money) -> Money {
        Money {
            yen: self.yen + other.yen,
        }
    }
}

fn main() {
    let price_a = Money { yen: 1200 };
    let price_b = Money { yen: 3400 };

    let total = price_a + price_b;

    println!("price_a: {:?}", price_a); // ここでコンパイルエラー
    println!("price_b: {:?}", price_b); // ここでもコンパイルエラー
    println!("total: {:?}", total);
}

要件

1. なぜこのコードがコンパイルエラーになるのか、Addトレイトのシグネチャに基づいて説明してください
2. main関数の意図（price_a・price_b・totalの3つをすべて表示したい）を保ったまま、コンパイルが通るように2通りの修正方法を実装してください
   • 修正案A: Moneyに#[derive(Clone, Copy)]を追加し、値をコピーで扱えるようにする方法
   • 修正案B: Moneyをコピーせず、&Money同士の加算（impl Add for &Money）を追加し、参照のまま&price_a + &price_bで計算する方法
3. 修正案Aと修正案Bのどちらが「実務でのMoney型」として適切か、トレードオフも含めて考察してください（Moneyのようなドメイン型は今後フィールドが増える可能性がある、という前提で検討してください）
4. #[cfg(test)]のテストで、修正後のコードが正しく動くことを検証してください

🔍 ヒント（段階的開示）

📋 コピー// 修正案A
#[derive(Debug, Clone, Copy)]
struct Money {
    yen: i64,
}

impl Add for Money {
    type Output = Money;
    fn add(self, other: Money) -> Money {
        Money { yen: self.yen + other.yen }
    }
}

// 修正案B（Aとは別のMoney定義として、またはAに追記する形で）
impl Add for &Money {
    type Output = Money;
    fn add(self, other: &Money) -> Money {
        Money { yen: self.yen + other.yen }
    }
}
// 呼び出し側: let total = &price_a + &price_b;

✅ 模範解答

📋 コピーuse std::ops::Add;

// 修正案A: Copy を導出し、値渡しでもムーブが起きない（実質コピー）ようにする
#[derive(Debug, Clone, Copy, PartialEq)]
struct MoneyCopy {
    yen: i64,
}

impl Add for MoneyCopy {
    type Output = MoneyCopy;

    fn add(self, other: MoneyCopy) -> MoneyCopy {
        MoneyCopy {
            yen: self.yen + other.yen,
        }
    }
}

// 修正案B: Copy を導出せず、&Money 同士の加算を追加で実装する
#[derive(Debug, PartialEq)]
struct MoneyRef {
    yen: i64,
}

impl Add for &MoneyRef {
    type Output = MoneyRef;

    fn add(self, other: &MoneyRef) -> MoneyRef {
        MoneyRef {
            yen: self.yen + other.yen,
        }
    }
}

fn main() {
    // 修正案A: 値のまま + が使える（price_a, price_b は暗黙のコピーで生き残る）
    let price_a = MoneyCopy { yen: 1200 };
    let price_b = MoneyCopy { yen: 3400 };
    let total_a = price_a + price_b;
    println!("[案A] price_a: {:?}", price_a);
    println!("[案A] price_b: {:?}", price_b);
    println!("[案A] total: {:?}", total_a);

    // 修正案B: 参照同士で + を使う（price_a, price_b の所有権は移動しない）
    let price_c = MoneyRef { yen: 1200 };
    let price_d = MoneyRef { yen: 3400 };
    let total_b = &price_c + &price_d;
    println!("[案B] price_c: {:?}", price_c);
    println!("[案B] price_d: {:?}", price_d);
    println!("[案B] total: {:?}", total_b);
}

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

    #[test]
    fn copy_variant_keeps_operands_usable() {
        let a = MoneyCopy { yen: 500 };
        let b = MoneyCopy { yen: 700 };
        let total = a + b;
        // Copy のおかげで a, b はこの後も使える
        assert_eq!(a.yen, 500);
        assert_eq!(b.yen, 700);
        assert_eq!(total, MoneyCopy { yen: 1200 });
    }

    #[test]
    fn ref_variant_keeps_operands_usable() {
        let a = MoneyRef { yen: 500 };
        let b = MoneyRef { yen: 700 };
        let total = &a + &b;
        // 参照で渡したので a, b の所有権は移動していない
        assert_eq!(a.yen, 500);
        assert_eq!(b.yen, 700);
        assert_eq!(total, MoneyRef { yen: 1200 });
    }
}

$ cargo run
[案A] price_a: MoneyCopy { yen: 1200 }
[案A] price_b: MoneyCopy { yen: 3400 }
[案A] total: MoneyCopy { yen: 4600 }
[案B] price_c: MoneyRef { yen: 1200 }
[案B] price_d: MoneyRef { yen: 3400 }
[案B] total: MoneyRef { yen: 4600 }

$ cargo test
running 2 tests
test tests::copy_variant_keeps_operands_usable ... ok
test tests::ref_variant_keeps_operands_usable ... ok

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

🪜 Step-by-Step 解説

📋 コピーimpl Add for &MoneyRef {
    type Output = MoneyRef;
    fn add(self, other: &MoneyRef) -> MoneyRef {
        MoneyRef { yen: self.yen + other.yen }
    }
}

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

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

元のコード（deriveなし、参照実装なしのMoney）をコンパイルすると、次のようなエラーが出ます。

読み方:

• borrow of moved value: 'price_a': price_aは既に別の場所（price_a + price_bの式）でムーブ済みであり、それ以降の参照・使用はできないという意味です
• move occurs because 'price_a' has type 'Money', which does not implement the 'Copy' trait: コンパイラが「なぜムーブが起きたか」の根本原因まで教えてくれています。MoneyがCopyでないため、値渡しは即ムーブになったということです
• `price_a` moved due to usage in operator: +演算子（＝Add::addの呼び出し）が原因でムーブが起きたことを、コンパイラが演算子だと名指しで教えてくれています
• note: calling this operator moves the left-hand side: 標準ライブラリのcore::ops::arith内の実装箇所を指し、「この演算子は左辺をムーブする」という事実そのものがRustの言語仕様であることを示しています
• note: if 'Money' implemented 'Clone', you could clone the value: コンパイラは.clone()というその場しのぎの修正案も提示しますが、これはMoneyにCloneが実装されていることが前提であり、かつ毎回クローンのコストが発生します。「そもそも安価な型ならCopyにする」「所有権を渡したくないなら&で演算する」という設計判断の方が根本的な解決になります

修正方法: 修正案Aまたは修正案Bのいずれかを適用する（本問題では両方を実装して比較する）。

🌐 他言語との比較

Rust以外の多くの言語では「演算子オーバーロードそのものを禁止する」（Go・Java・TypeScript）か、「参照渡しをデフォルトにして所有権の移動という概念自体を薄める」（C++）ことで、今回のような「演算後に元の変数が使えなくなる」という問題を回避しています。Rustが値渡しをデフォルトにしているのは、「所有権を移動させる操作なのか、借用で済む操作なのか」を演算子レベルでも型システムに正直に反映させるためであり、その代償として今回のようなムーブエラーに遭遇することになりますが、これは「バグを未然にコンパイル時に検出している」というRustの一貫した設計思想の表れでもあります。

🏆 実務での使いどころ

• ドメイン型の四則演算: 金額（Money）・ベクトル演算（Vector3）・座標変換など、業務ロジック上「型どうしの演算」が頻出するドメインでは、std::opsの実装によってtotal = price_a + price_b + shipping_feeのような直感的な式がそのまま書けるようになります
• Copy vs 参照実装の判断: 「フィールドが小さくコピーコストが無視できるならCopy、将来ヒープ確保フィールド（String・Vec等）を持つ可能性があるなら参照実装」という判断基準は、実務でドメイン型を設計する際に毎回問われる問題です
• AddAssign（+=）との組み合わせ: 実務ではtotal += priceのような累積処理も頻出するため、Addと合わせてstd::ops::AddAssign（fn add_assign(&mut self, rhs: Rhs)、こちらは&mut selfを取るため所有権の問題が起きにくい）を実装するケースも多くあります

⚠️ よくある誤解・ミス

🚀 次のステップ

• 発展: MoneyRefにAddAssign（+=）を追加実装し、let mut total = MoneyRef { yen: 0 }; total += δのような累積処理を書いてみてください（&mut selfを使うため、今回のムーブ問題がそもそも起きないことも確認してください）
• 次回予告: Day 015ではDeref/DerefMutトレイトを扱います。スマートポインタが*演算子や自動参照外しでどのように「中身の型のように振る舞う」のかを学びます

🎯 自己評価

自分の回答

気づき・メモ