Day 007 — 借用と参照（& と &mut）

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

Day 003〜006では「所有権のムーブ」を学びました。値を関数に渡すと所有権ごと移動し、呼び出し元ではもう使えなくなる——これがRustの基本ルールでした。しかし、これでは不便な場面が多くあります。

📋 コピーfn calculate_length(s: String) -> usize {
    s.len()
}

fn main() {
    let text = String::from("hello");
    let len = calculate_length(text);
    // ここで text はもう使えない（ムーブされたので）
    println!("{}", text); // コンパイルエラー！
}

calculate_lengthは文字列の長さを知りたいだけなのに、Stringの所有権ごと奪ってしまいます。呼び出し元でtextを使い続けたいなら、Day 005で見たTake & Returnパターンのように(String, usize)のタプルで返す必要がありますが、これは冗長です。

借用（Borrowing）——所有権を渡さずに値を使わせてもらう

Rustはこの問題を借用という仕組みで解決します。&を付けて参照を渡せば、所有権を移動させずに値へのアクセスだけを貸し出せます。

📋 コピーfn calculate_length(s: &String) -> usize {
    s.len()
}

fn main() {
    let text = String::from("hello");
    let len = calculate_length(&text); // &text で「借用」を渡す
    println!("{} is {} bytes", text, len); // text はまだ使える！
}

&textは「textの所有権を渡すのではなく、一時的に参照を貸す」という意味です。calculate_lengthが終わってs（参照）がスコープを抜けても、貸した本体（textが持つString）は破棄されません。あくまで借りているだけだからです。

不変借用（&T）と可変借用（&mut T）

参照には2種類あります。

📋 コピーfn append_world(s: &mut String) {
    s.push_str(", world");
}

fn main() {
    let mut greeting = String::from("hello"); // mut が必要
    append_world(&mut greeting); // &mut greeting で可変借用を渡す
    println!("{}", greeting); // "hello, world"
}

&mutで借りるには、借用元の変数自体がlet mutで宣言されていなければなりません。また、Rustには借用規則という重要な制約があります。

この規則により、「誰かがデータを読んでいる最中に、別の誰かがそのデータを書き換えてしまう」というデータ競合がコンパイル時に排除されます。C++やGoでは実行時（あるいは-race検出ツールなど）でしか気づけない類のバグを、Rustはコンパイラが型チェックの一部として静的に防ぎます。

📝 問題

1. 概念理解課題: 上記のcalculate_length(s: String)版とcalculate_length(s: &String)版を比較し、借用を使うことでDay 005のTake & Returnパターン（fn f(s: String) -> (String, usize)のように所有権を返し直す設計）が不要になる理由を説明してください
2. 実装課題（不変借用）: fn calculate_length(s: &String) -> usizeを実装し、main内でStringを作成→calculate_length(&text)を呼び出す→呼び出し後もtextをそのままprintln!で表示できることを確認するコードを書いてください
3. 実装課題（可変借用）: fn append_world(s: &mut String)を実装し、s.push_str(", world")で文字列を書き換えてください。main内でlet mut greetingを用意し、append_world(&mut greeting)を呼び出した後のgreetingを表示してください
4. デバッグ予測課題: 以下のコードはコンパイルエラーになります。発生するエラーコード（E0xxx）と、なぜ許されないのかを「借用規則」の観点で予想してください

   📋 コピーfn main() {
       let mut s = String::from("hello");
       let r1 = &mut s;
       let r2 = &mut s; // ここでエラー
       println!("{}, {}", r1, r2);
   }

5. 発展の概念理解（コードは不要）: もし仮にRustが「同時に複数の&mut」を許してしまったら、マルチスレッドで同じデータに対して2つの&mut Stringを別スレッドが持ってしまうケースを考えてください。どのようなバグが起こり得ますか？（ヒント: 片方がpush_strで文字列を伸ばしてメモリを再確保している最中に、もう片方が同じメモリを読み書きしたら？）

🔍 ヒント（段階的開示）

📋 コピーfn calculate_length(s: &String) -> usize {
    s.len()
}

fn append_world(s: &mut String) {
    s.push_str(", world");
}

fn main() {
    // 問題2: 不変借用
    let text = String::from("hello");
    let len = calculate_length(&text);
    println!("{} is {} bytes", text, len);

    // 問題3: 可変借用
    let mut greeting = String::from("hello");
    append_world(&mut greeting);
    println!("{}", greeting);

    // 問題4は実際にはコメントアウトのまま、エラーを予想するだけでよい
    // let mut s = String::from("hello");
    // let r1 = &mut s;
    // let r2 = &mut s; // ここでエラーになるはず
    // println!("{}, {}", r1, r2);
}

✅ 模範解答

📋 コピーfn calculate_length(s: &String) -> usize {
    s.len()
}

fn append_world(s: &mut String) {
    s.push_str(", world");
}

fn main() {
    // --- 実装課題2: 不変借用 ---
    let text = String::from("hello");
    let len = calculate_length(&text); // &text で借用を渡す
    println!("{} is {} bytes", text, len); // text はムーブされていないのでまだ使える

    println!("---");

    // --- 実装課題3: 可変借用 ---
    let mut greeting = String::from("hello"); // &mut で借りるには mut 宣言が必要
    append_world(&mut greeting);
    println!("{}", greeting); // "hello, world"
}

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

    #[test]
    fn test_calculate_length() {
        let text = String::from("hello");
        assert_eq!(calculate_length(&text), 5);
        // 借用しただけなので text はテスト内でも使い続けられる
        assert_eq!(text, "hello");
    }

    #[test]
    fn test_append_world() {
        let mut greeting = String::from("hello");
        append_world(&mut greeting);
        assert_eq!(greeting, "hello, world");
    }
}

$ cargo run
hello is 5 bytes
---
hello, world

$ cargo test
running 2 tests
test tests::test_append_world ... ok
test tests::test_calculate_length ... ok

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

🪜 Step-by-Step 解説

📋 コピーlet len = calculate_length(&text);

📋 コピーprintln!("{} is {} bytes", text, len);

📋 コピーlet mut greeting = String::from("hello");
append_world(&mut greeting);

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

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

問題4のコードです。

📋 コピーfn main() {
    let mut s = String::from("hello");
    let r1 = &mut s;
    let r2 = &mut s; // ← ここでエラー
    println!("{}, {}", r1, r2);
}

読み方:

• error[E0499]: 「同じ値を同時に2回以上、可変借用しようとした」ことを示すエラーコードです
• first mutable borrow occurs here: r1が最初の可変借用であることを示しています
• second mutable borrow occurs here: r2を作ろうとした時点で、まだr1が生きている（後でprintln!で使われる）ため、2個目の可変借用が拒否されています
• first borrow later used here: r1がprintln!の中で実際に使われるコードなので、コンパイラは「r1はまだ有効に生きている」と判断し、その状態でr2を作ることを許しません

修正方法: 同時に2つの可変借用が必要になる設計そのものを避けるのが基本です。多くの場合、r1を使い終わってから（スコープを抜けてから）改めてr2を作れば解決します。

📋 コピーfn main() {
    let mut s = String::from("hello");
    {
        let r1 = &mut s;
        println!("{}", r1);
    } // r1 のスコープがここで終わる
    let r2 = &mut s; // r1 が死んでいるので OK
    println!("{}", r2);
}

なお、不変借用&s同士であれば何個でも同時に存在できます。&s1と&mut s2のように別の変数を指している場合も、当然ながら同時に借用できます。エラーになるのは同じ値に対して可変借用が複数、または不変借用と可変借用が同時に生きている場合だけです。

🌐 他言語との比較

Go・Java・C++はいずれも「複数の書き込み可能な参照を同時に持てる」ため、データ競合の防止はプログラマの規律とツール（レースディテクタ・ロック）に依存します。Rustは言語仕様として「複数の&mutを同時に存在させること自体ができない」ため、単一スレッドのコードであっても借用規則が一貫して適用され、後にマルチスレッド化する際も同じ規則がそのまま安全性を保証します。

🏆 実務での使いどころ

• 関数への軽量な値渡し: StringやVec<T>のような所有権付きの大きな値を関数に渡すとき、関数側が値を変更・保持する必要がなければ&Tで渡すのが基本です。所有権のムーブやクローンのコストを避けられます
• その場での更新処理: fn normalize(v: &mut Vec<i32>)のように、呼び出し元のデータをその場で書き換える関数（ソート・正規化・バリデーション後の修正など）は&mut Tで受け取るのが定石です
• 借用チェッカーがAPI設計を導く: 「この関数は読むだけでいいのか、書き換える必要があるのか」を&Tと&mut Tの選択によって明示することになるため、関数シグネチャを見るだけで副作用の有無が分かる設計になります
• 並行処理への布石: Phase 3で学ぶArc<Mutex<T>>やRwLock<T>は、まさにこの「共有読み取り or 排他書き込み」という借用規則をスレッドをまたいで実現する仕組みです。ここで学ぶ規則がそのままマルチスレッド設計の基礎になります

⚠️ よくある誤解・ミス

🚀 次のステップ

• 発展: 1つの関数内で「不変借用が生きている間は可変借用を作れない」というケースも試してみてください（例: let r1 = &s; let r2 = &mut s;）。エラーコードはE0502になります。今日のE0499（可変×可変）との文言の違いを比較すると理解が深まります
• 次回予告: Day 008ではスライス型（&str・&[T]）へ進みます。今日学んだ「借用」の考え方が、String全体ではなく一部分だけを指す参照としてどう応用されるかを見ていきます

🎯 自己評価

自分の回答

気づき・メモ