Day 004 — 所有権の基礎（ムーブセマンティクス）

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

Day 003では「単純な変数の代入・関数呼び出し」でのムーブを扱いました。今日はもう一歩進んで、コレクション（Vec<T>）の要素に対してムーブ規則がどう働くかを見ていきます。

Vecのインデックスアクセスは何を返しているか

vec[i]という書き方は、実はIndexトレイトのindex()メソッド呼び出しの糖衣構文で、内部的には&T（要素への参照）を返します。ところが

📋 コピーlet item = fruits[i];

のようにletで直接受けようとすると、コンパイラは*fruits.index(i)という形で暗黙に参照外し（デリファレンス）をしてから代入しようとします。要素の型がStringのようにCopyを実装していない場合、これはその要素の所有権をVecの外へムーブする操作になります。

なぜVecはこれを許さないのか

Vec<T>は内部的に「連続したメモリ領域に、有効なTの値がすきまなく並んでいる」という不変条件（invariant）を保つことで動作しています。もしfruits[1]だけ所有権を抜き取ってしまうと、その位置は「値が存在しない穴」になります。しかしVecはその穴の存在を表現する手段を持っていません（Option<T>の配列ではなくTそのものの配列だからです）。この状態で他のインデックスアクセスやDrop（スコープを抜けるときの後片付け）が走ると、存在しない値を読み書きしてしまう未定義動作につながります。

Rustの借用チェッカーは、この危険な操作をコンパイル時に完全に検出して拒否します。これが今日のデバッグ問題の主役、E0507: cannot move out of index of Vec<T>です。

対処法は3つ

1. 借用する（&fruits[i]）: 所有権を移動させず、参照だけを渡す。最も一般的な解決策
2. .clone()する: 要素を複製して独立した所有権を得る。元のVecはそのまま使える
3. Vec全体をinto_iter()で消費する: 「一部だけ穴を開ける」のではなく「Vec全体を丸ごと所有権ごと消費する」なら、不変条件を壊さないので合法です

📝 問題

以下のコードにはコンパイルエラーが発生する箇所があります。

📋 コピーfn print_summary(item: String) {
    println!("summary: {}", item);
}

fn main() {
    let fruits = vec![
        String::from("apple"),
        String::from("banana"),
        String::from("cherry"),
    ];

    for i in 0..fruits.len() {
        let item = fruits[i];
        print_summary(item);
    }

    println!("all fruits: {:?}", fruits);
}

次の問いに答えてください。

1. どの行でコンパイルエラーが発生するか。Vecが保つ不変条件と所有権の観点から、なぜfruits[i]をそのままletで受けられないのかを説明してください
2. 発生するコンパイルエラーのエラーコード（E0xxx）と、おおまかなメッセージ内容を予想してください
3. このコードを2通りの方法で修正してください
   • 方法A: &fruits[i]で借用し、print_summaryのシグネチャを参照を受け取る形に変更する
   • 方法B: fruits[i].clone()でディープコピーし、fruits自体はそのまま使えるようにする
4. 追加の実装課題: fn total_length(items: &[String]) -> usize を実装し、fruitsの所有権を消費せずに全要素の文字数合計を求めてください（スライス&[String]を借用するAPI設計の練習です）
5. オプション課題: ループ後にfruitsを一切使わなくてよい場合、for i in 0..fruits.len()ではなくfor item in fruits.into_iter()（あるいは単にfor item in fruits）と書くとエラーなくコンパイルできる理由を説明してください

🔍 ヒント（段階的開示）

📋 コピーfn print_summary(item: &str) {
    println!("summary: {}", item);
}

fn total_length(items: &[String]) -> usize {
    // items.iter() で借用しながら各要素のlen()を合計する
    items.iter().map(|s| s.len()).sum()
}

fn main() {
    let fruits = vec![
        String::from("apple"),
        String::from("banana"),
        String::from("cherry"),
    ];

    // 方法A: 借用でループする
    for i in 0..fruits.len() {
        let item = &fruits[i];
        print_summary(item);
    }

    println!("all fruits: {:?}", fruits);
    println!("total length: {}", total_length(&fruits));

    // オプション課題: into_iter() で丸ごと消費する版（別ブロックで確認）
    let fruits2 = vec![String::from("kiwi"), String::from("mango")];
    for item in fruits2.into_iter() {
        print_summary(&item);
    }
    // ここで fruits2 を使おうとするとコンパイルエラーになる（丸ごとムーブ済みのため）
}

✅ 模範解答

📋 コピーfn print_summary(item: &str) {
    println!("summary: {}", item);
}

fn total_length(items: &[String]) -> usize {
    items.iter().map(|s| s.len()).sum()
}

fn main() {
    let fruits = vec![
        String::from("apple"),
        String::from("banana"),
        String::from("cherry"),
    ];

    // --- 方法A: 借用でループする（fruitsの所有権は失わない） ---
    for i in 0..fruits.len() {
        let item = &fruits[i]; // &String を得るだけ。ムーブは発生しない
        print_summary(item);   // &String は &str へ自動でderef coercionされる
    }

    println!("---");

    // ループを抜けた後も fruits は完全に有効
    println!("all fruits: {:?}", fruits);

    // 追加課題: total_length はスライスを借用するだけなので fruits の所有権は消費しない
    println!("total length: {}", total_length(&fruits));

    println!("---");

    // --- 方法B: clone() でディープコピーする版（別のVecで確認） ---
    let fruits_b = vec![String::from("grape"), String::from("melon")];
    for i in 0..fruits_b.len() {
        let item = fruits_b[i].clone(); // 要素を複製。fruits_bの所有権は無傷
        print_summary(&item);
    }
    println!("fruits_b (still valid): {:?}", fruits_b);

    println!("---");

    // --- オプション課題: into_iter() で Vec 全体を消費する版 ---
    let fruits2 = vec![String::from("kiwi"), String::from("mango")];
    for item in fruits2.into_iter() {
        // item はループのたびに所有権ごと渡ってくる（Vec全体を明け渡しているので合法）
        print_summary(&item);
    }
    // ここで println!("{:?}", fruits2); と書くとコンパイルエラーになる
    // （fruits2はinto_iter()で丸ごとムーブ済みのため、あえて書かない）
}

summary: apple
summary: banana
summary: cherry
---
all fruits: ["apple", "banana", "cherry"]
total length: 16
---
summary: grape
summary: melon
fruits_b (still valid): ["grape", "melon"]
---
summary: kiwi
summary: mango

🪜 Step-by-Step 解説

📋 コピーfor i in 0..fruits.len() {
    let item = fruits[i]; // ここでE0507
    print_summary(item);
}

📋 コピーlet item = &fruits[i];

📋 コピーlet item = fruits_b[i].clone();

📋 コピーfn total_length(items: &[String]) -> usize {
    items.iter().map(|s| s.len()).sum()
}

📋 コピーfor item in fruits2.into_iter() {
    print_summary(&item);
}

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

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

元のコード（修正前）をそのままコンパイルすると、次のようなエラーが出ます。

📋 コピーfn main() {
    let fruits = vec![String::from("apple"), String::from("banana"), String::from("cherry")];
    for i in 0..fruits.len() {
        let item = fruits[i]; // ここでE0507
        println!("{}", item);
    }
}

読み方:

• error[E0507]: 「借用された内容からムーブしようとした」エラー。Indexが返す参照の先にある値を、所有権ごと取り出そうとしたときに出ます
• move occurs because value has type ... does not implement the Copy trait: StringがCopyでないため、この操作がムーブとして扱われたことを説明しています
• help: consider borrowing here: rustcは「参照にすれば解決する」ことまで具体的に提案してくれます。実際、多くの場合このhelp通りに&を1つ足すだけで解決します

修正方法: 「模範解答」セクションの方法A（&で借用）、方法B（.clone()）、あるいはinto_iter()でVec全体を消費するかのいずれかを状況に応じて選びます。

🌐 他言語との比較

C++との対比が特に示唆的です。C++でもstd::move(vec[i])によって要素の所有権だけを抜き取ることは技術的には可能ですが、その結果vec[i]は「有効だが未規定な状態」として残り続けます。うっかりその要素に再アクセスしてしまうバグは、実行時まで発覚しません。Rustはこの危険な操作自体を型システムレベルで存在させない（コンパイルが通らない）ことで、同じクラスのバグを設計から排除しています。

🏆 実務での使いどころ

• バッチ処理でのVec消費: キューやバッチジョブの結果を1件ずつ所有権ごと処理して破棄したい場合、for item in vec.into_iter() { process(item); }は「処理後に元のVecへ戻る必要がない」ことをコード自体が表明する、意図の明確なイディオムです
• 読み取り専用APIでのスライス活用: total_lengthのように&[T]を引数に取る関数は、Vec<T>・配列・他のスライスのいずれからも呼び出せる汎用的なAPIになります。「所有権が要らないなら&[T]」は実務でも頻出の設計判断です
• 借用チェッカーのエラーに出会ったときの判断フロー: 「①本当に所有権が必要か（不要なら借用に変える）→ ②所有権が必要だが元のデータも残したいか（.clone()）→ ③元のデータをもう使わないなら丸ごと消費してよいか（into_iter()やムーブ）」という順で検討する癖をつけると、無駄な.clone()の濫用を避けられます
• deref coercionの実務上の恩恵: 方法Aで&Stringを&str引数の関数にそのまま渡せたように、Rustは参照の型変換を多くの場面で自動的に行います。関数シグネチャを設計するときは、可能な限り&str・&[T]のような「受け取り側に優しい」borrowed型を選ぶのがイディオマティックです

⚠️ よくある誤解・ミス

🚀 次のステップ

• 発展: 今回&fruits[i]という借用を使いましたが、これは不変参照（&）です。もしループの中で要素を書き換えたい場合は可変参照（&mut）が必要になり、「同時に複数の可変参照を持てない」という借用規則が新たに関わってきます。fruits.iter_mut()を使って各要素の文字列に.push_str("!")する処理を書いてみると、次回のテーマへの橋渡しになります
• 次回予告: 引き続き所有権の基礎（ムーブセマンティクス）を扱いつつ、理解が安定してきたら Day 006 前後で借用と参照（& と &mut）へ本格的に進みます（借用規則（同時可変参照の禁止）の意味）

🎯 自己評価

自分の回答

気づき・メモ