Rustの & と * がわかる！

1.そもそも「参照」ってなに？ — 住所のメモにたとえる

Rustでは、値（データ）はどこかのメモリに置かれています。参照（reference）とは、その値が置いてある「住所を書いたメモ」のようなものです。

なぜ住所メモ（参照）が必要なのでしょう？ Rustには所有権（ownership）というルールがあり、値を関数に「そのまま渡す」と、値の持ち主が移ってしまいます（ムーブ）。元の場所からは使えなくなります。

fn eat(s: String) {}   // String を「もらう」関数

fn main() {
    let s = String::from("apple");
    eat(s);            // 所有権が eat に移動（ムーブ）
    // println!("{}", s);  // ❌ もう s は使えない！
}

「家ごとあげる」のではなく「住所だけ教える（貸す）」のが参照です。貸すだけなら、あとで自分も使えます。これを借用（borrow）と呼びます。

fn look(s: &String) {}  // String を「借りる」関数

fn main() {
    let s = String::from("apple");
    look(&s);           // 住所だけ渡す（借用）
    println!("{}", s);  // ✅ s はまだ自分のもの
}

2.& と * — 借りる、中身を取り出す

2つの記号はペアで覚えましょう。逆の操作です。

let x: i32 = 42;
let r: &i32 = &x;   // & で参照を作る

println!("{}", *r); // * で中身を取り出す → 42
assert_eq!(*r, 42); // *r は i32 の 42 そのもの

3.&mut arg — 「書きこみOK」で貸す

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

「図書館の本（みんなで読める）」と「原本の編集権（同時に1人だけ）」の違いだと思ってください。編集する人が2人いたら本がぐちゃぐちゃになるからです。

fn add_ten(n: &mut i32) {   // 「書きこみOKの住所メモ」を受け取る
    *n += 10;               // * で中身を開けて書きこむ
}

fn main() {
    let mut x = 5;          // 貸す側も mut にしておく必要がある
    add_ten(&mut x);        // &mut で「編集権つき」で貸す
    println!("{}", x);      // → 15 （呼び出し元の x が変わった！）
}

let x = 1;
let a = &x;
let b = &x;   // 読むだけなら何枚でもOK
println!("{} {}", a, b);

let mut x = 1;
let a = &mut x;
let b = &mut x; // ❌ 編集権は同時に1つ
println!("{} {}", a, b);

4.** — 参照の参照を2回はがす

「住所メモの住所メモ」も作れます。&&i32 は「i32 への参照」への参照です。中の値にたどり着くには * を2回使います。それが ** です。

let x: i32   = 42;
let r: &i32  = &x;    // 参照
let rr: &&i32 = &r;   // 参照の参照

println!("{}", **rr); // * を2回 → 42
//  *rr は &i32（1枚はがれた）
// **rr は  i32（2枚はがれた）

実際によく出会う場所：イテレータ

わざわざ && を自分で書くことは少ないですが、イテレータの中で自然に発生します。

let nums = vec![1, 2, 3, 4];

// .iter() は &i32 を返す。filter のクロージャは
// その参照をさらに借りるので、引数 n は &&i32 になる！
let evens: Vec = nums
    .iter()                     // Item = &i32
    .filter(|n| **n % 2 == 0)   // n: &&i32 → ** で i32 に
    .copied()
    .collect();

assert_eq!(evens, vec![2, 4]);

5.自動デリファレンス — * を書かなくていい場面

「え、でも普段 * なんてほとんど書いてないけど？」——そのとおりです。Rustはメソッド呼び出し（.）や比較の多くで、自動的に * を補ってくれます（auto-deref）。

let s = String::from("hello");
let r: &String = &s;

// .len() を呼ぶとき、r を自分で *r にしなくていい
println!("{}", r.len());     // ✅ 自動で (*r).len() になる

// println! も参照を自動で追いかけて表示してくれる
println!("{}", r);           // ✅ hello

逆に、自分で * を書かないといけないのは主にこんなときです。

6.arg.as_mut() — 中身への可変参照をもらう

&mut x が「変数を直接借りる」だったのに対して、as_mut() は「箱に入った値の、中身への可変参照をもらう」メソッドです。代表選手は Option です。

Option::as_mut() — 箱を開けずに中身を編集する

Option<T> は「値が入っているかもしれない箱」。as_mut() を使うと、箱の所有権を奪わずに（箱を壊さずに）、中身 T への &mut を取り出せます。

let mut maybe_score: Option = Some(80);

// as_mut(): Option → Option<&mut i32>
if let Some(score) = maybe_score.as_mut() {
    *score += 5;              // score: &mut i32 なので * で書きこむ
}

assert_eq!(maybe_score, Some(85));  // ✅ 箱はそのまま、中身だけ変わった

let mut m: Option =
    Some("hi".into());

// if let Some(s) = m { ... }
// ❌ 中身がムーブして箱が壊れる
//    （String はコピーできない）

let mut m: Option =
    Some("hi".into());

if let Some(s) = m.as_mut() {
    s.push_str(" there"); // 中身を編集
}
// m は Some("hi there") のまま健在

&mut x と x.as_mut() の使い分け

7.まとめチートシート

最後に、今日の全部が入ったコードです。

fn add_ten(n: &mut i32) {
    *n += 10;                          // ③ * で中身に書きこむ
}

fn main() {
    let mut x = 5;
    add_ten(&mut x);                   // ① &mut で編集権つきで貸す
    assert_eq!(x, 15);

    let nums = vec![1, 2, 3, 4];
    let evens: Vec = nums
        .iter()
        .filter(|n| **n % 2 == 0)      // ② ** で2枚はがす
        .copied()
        .collect();
    assert_eq!(evens, vec![2, 4]);

    let mut best: Option = Some(evens[0]);
    if let Some(b) = best.as_mut() {   // ④ as_mut で中身への &mut
        *b = 100;
    }
    assert_eq!(best, Some(100));
}