Rustというプログラミング言語を学ぶ上で、避けては通れない最も重要な概念が「所有権」です。

多くのプログラミング言語では、ガベージコレクションや明示的なメモリ解放によってメモリを管理しますが、Rustは独自の所有権システムを採用しています。

このシステムを理解することで、メモリ安全性を確保しながら高い実行パフォーマンスを発揮するプログラムを記述できるようになります。

本記事では、初心者の方でも直感的に理解できるように、所有権の基本ルールからエラーの回避方法までを丁寧に解説していきます。

目次 [ close ]
  1. 所有権が必要な理由とメモリの仕組み
    1. スタックとヒープの違い
  2. 所有権の3つの基本ルール
    1. ルール1：すべての値には所有者がいる
    2. ルール2：所有者は一人だけ（ムーブセマンティクス）
    3. ルール3：スコープを外れると値は破棄される
  3. 所有権の移動(ムーブ)とコピーの違い
    1. Copyトレイトを持つ型
    2. 所有権が移動する型
  4. 参照と借用：所有権を渡さずにデータを使う
    1. 不変の参照と可変の参照
    2. 借用のルール（ボローチェッカー）
  5. よく遭遇する所有権エラーと解決策
    1. 1. 使用済みの変数へのアクセス (value borrowed here after move)
    2. 2. 複数の可変参照の作成 (cannot borrow as mutable more than once)
    3. 3. 吊り下げ参照 (dangling reference)
  6. 所有権を使いこなすためのヒント
  7. まとめ

所有権が必要な理由とメモリの仕組み

プログラミング言語がメモリを管理する方法には、大きく分けて3つのアプローチが存在します。

1つ目はC言語やC++のように、開発者が手動でメモリの確保と解放を行う方法です。

2つ目はJavaやPythonのように、ガベージコレクタ(GC)が実行時に不要なメモリを自動的に回収する方法です。

3つ目が、Rustが採用している「コンパイル時にメモリ管理のルールをチェックする」という方法です。

手動管理はミスが発生しやすく、ガベージコレクタは実行時のオーバーヘッドが発生するという課題があります。

Rustの所有権システムは、これら両方の問題を解決し、安全性と速度を両立させるために生み出されました。

この仕組みを理解するためには、まず「スタック」と「ヒープ」という2つのメモリ領域について知る必要があります。

スタックとヒープの違い

スタックは、データを入れた順番とは逆の順番で取り出す「後入れ先出し(LIFO)」の構造を持った高速なメモリ領域です。

スタックに保存されるデータは、コンパイル時にそのサイズが固定されている必要があります。

一方でヒープは、実行時にサイズが変わる可能性のあるデータを格納するための自由度の高い領域です。

ヒープにデータを置く場合、OSは十分な空きスペースを探してそこを確保し、その場所を指し示す「ポインタ」を返します。

このポインタ自体は固定サイズなのでスタックに保存されますが、実際のデータ本体はヒープの中に存在します。

Rustの所有権システムは、主にこのヒープ上のデータを効率的かつ安全に管理するために機能します。

所有権の3つの基本ルール

Rustの所有権を支えるルールは、驚くほどシンプルで以下の3点に集約されます。

  • Rustの各値は、所有者と呼ばれる変数と対応している。
  • いかなる時も、所有者はただ一人である。
  • 所有者がスコープから外れたら、その値は破棄される。

これらのルールがコンパイル時に厳格にチェックされることで、メモリリークや不正なアクセスを防いでいます。

ルール1：すべての値には所有者がいる

Rustでは、プログラム内のあらゆるデータに対して、その責任を持つ変数が割り当てられます。

例えば、文字列を扱うString型を定義したとき、その変数名がデータの所有者となります。

Rust
fn main() {
    // sという変数が、ヒープ上の文字列データの所有者になる
    let s = String::from("hello");
}

ルール2：所有者は一人だけ（ムーブセマンティクス）

これは他の言語と大きく異なるRust最大の特徴です。

ある変数を別の変数に代入すると、データの所有権が移動(ムーブ)します。

所有権が移動した後は、元の変数を使用してデータにアクセスすることはできません。

Rust
fn main() {
    let s1 = String::from("hello");
    // s1からs2へ所有権が移動する
    let s2 = s1;

    // println!("{}", s1); // ここでエラーが発生する
    println!("{}", s2); // s2は所有者なのでアクセス可能
}

この仕組みにより、同じメモリ領域を指す複数の変数が同時に存在することで発生する「二重解放エラー」を防いでいます。

ルール3：スコープを外れると値は破棄される

変数が定義されたブロック(波括弧 {})を抜けると、その変数の有効範囲(スコープ)が終了します。

スコープが終わる瞬間、Rustは自動的にdropという特別な関数を呼び出し、ヒープメモリを解放します。

これにより、開発者が手動でfreeなどの命令を書く必要がなくなります。

Rust
{
    let s = String::from("hello"); // sはこのスコープ内で有効
} // ここでスコープが終了し、sのメモリは自動的に解放される

所有権の移動(ムーブ)とコピーの違い

先ほどの例では、代入によって所有権が移動しましたが、すべての型で移動が発生するわけではありません。

データの型によって「ムーブ」されるものと「コピー」されるものに分かれます。

Copyトレイトを持つ型

整数型(i32など)や論理値型(bool)などの、サイズがコンパイル時に決まっている単純な型は、代入時にデータが複製されます。

これを「Copyトレイトを実装している」と表現します。

Rust
let x = 5;
let y = x; // xの値がyにコピーされる
println!("x: {}, y: {}", x, y); // 両方とも使用可能

スタック上のデータのみを複製するため、処理コストが非常に低く、所有権の移動を気にする必要がありません。

所有権が移動する型

StringやVecなどのヒープを利用する複雑な型は、デフォルトでムーブが発生します。

ヒープ内のデータ本体を物理的にコピーするとコストが高くなるため、Rustはデフォルトで「所有権の譲渡」のみを行います。

もし、どうしてもデータを複製したい場合は、cloneメソッドを使用します。

Rust
let s1 = String::from("hello");
let s2 = s1.clone(); // ヒープ上のデータも複製される
println!("s1: {}, s2: {}", s1, s2); // cloneした場合は両方使用可能

ただし、cloneはメモリと実行時間の両方を消費するため、乱用は避けるべきです。

参照と借用：所有権を渡さずにデータを使う

関数に値を渡すたびに所有権が移動してしまうと、プログラミングは非常に不便になります。

そこでRustには、所有権を移動させずにデータにアクセスする「借用(Borrowing)」という仕組みがあります。

変数の前に & を付けることで、データの参照を作成できます。

Rust
fn main() {
    let s1 = String::from("hello");
    // &s1を渡すことで、所有権を貸し出す（借用）
    let len = calculate_length(&s1);
    println!("'{}' の長さは {} です。", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
} // sは参照なので、ここではドロップされない

不変の参照と可変の参照

参照には、読み取り専用の「不変の参照」と、データを書き換えられる「可変の参照」の2種類があります。

可変の参照を作成するには、&mut を使用します。

Rust
fn main() {
    let mut s = String::from("hello");
    change(&mut s);
    println!("{}", s);
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

借用のルール（ボローチェッカー）

Rustは、データの不整合（データ競合）を防ぐために、参照に関して非常に厳しいルールを設けています。

このルールを監視するコンパイラの機能を「ボローチェッカー」と呼びます。

ルールの種類内容
不変の参照（&T）同時にいくつでも作成可能
可変の参照（&mut T）特定のスコープ内でたった一つしか作成できない

「不変の参照と可変の参照を同時には持てない」という点も重要です。

誰かがデータを読み取っている最中に、別の誰かがデータを書き換えてしまうと、予期せぬ動作が発生する可能性があるからです。

よく遭遇する所有権エラーと解決策

Rustの学習者が最初によく遭遇するコンパイルエラーを例に、その解決方法を見ていきましょう。

1. 使用済みの変数へのアクセス (value borrowed here after move)

これは、所有権が移動した後の変数を使おうとした場合に発生します。

Rust
let s1 = String::from("Rust");
let s2 = s1;
println!("{}", s1); // Error!

解決策： 所有権を移動させたくない場合は、参照 &s1 を渡すか、必要であれば clone() を検討してください。

2. 複数の可変参照の作成 (cannot borrow as mutable more than once)

同じデータに対して複数の可変参照を作ろうとしたときに発生します。

Rust
let mut s = String::from("hello");
let r1 = &mut s;
let r2 = &mut s; // Error!
println!("{}, {}", r1, r2);

解決策： 可変参照のスコープを分けるか、設計を見直して同時に複数の書き込みが発生しないようにします。

3. 吊り下げ参照 (dangling reference)

関数内で作成したデータの参照を、関数外に返そうとすると発生します。

Rust
// これはコンパイルエラーになります
// fn dangle() -> &String {
//     let s = String::from("hello");
//     &s // sは関数の終わりで破棄されるため、その参照を返すことはできない
// }

解決策： 参照ではなく、所有権そのもの(String)を戻り値として返すようにします。

所有権を使いこなすためのヒント

所有権は、最初は制限が多いように感じられますが、慣れてくると「バグを未然に防いでくれる頼もしい味方」になります。

コードを設計する際は、常に「このデータの所有者は誰か？」「いつまでこのデータが必要か？」を意識することが大切です。

また、Rustのコンパイラが出力するエラーメッセージは非常に親切で、修正案を提示してくれることも多いです。

エラーが出たときは、まずメッセージを読み、どのルールに違反しているのかを確認する習慣をつけましょう。

スライス(Slice)などの機能を組み合わせることで、所有権を維持したまま、データの一部を効率的に扱う技術も身についていきます。

まとめ

Rustの所有権システムは、メモリの安全性をコンパイル時に保証する画期的な仕組みです。

本記事で解説した以下のポイントを心に留めておきましょう。

  • 値には必ず一人の所有者がおり、スコープを抜けると自動的にメモリが解放される。
  • 代入や関数の引数渡しによって、所有権はムーブ(移動)する。
  • &（参照）を使うことで、所有権を渡さずにデータを借用できる。
  • 不変の参照は複数可能だが、可変の参照は一度に一つしか作れない。

最初はボローチェッカーに叱られることも多いかもしれませんが、それはプログラムが実行時にクラッシュするのを防いでくれている証拠です。

所有権のルールを理解し、使いこなすことで、堅牢で高速なRustの世界を存分に楽しんでください。