🫥
Rustの所有権に入門した

2025/03/08に公開
 はじめに最近Rustに入門し、「The Rust Programming Language」でRustの基礎を学んでいます。今回は復習として重要な概念である「所有権」について、私自身がつまずきやすかった点や、重要だと感じた点を簡潔にまとめています。
所有権は、Rustがメモリ安全性を保証するための強力な仕組みであり、これを理解することで、メモリリークやダングリングポインタといったバグをコンパイル時に防ぐことができます。これは、Rustが高速でありながら安全なシステムプログラミング言語として注目される大きな理由の一つです。
この記事では、所有権の基本から、ムーブ、クローン、コピー、借用、そしてドロップといった関連概念、さらに関数との関係まで、順を追って解説していきます。

 所有権とは？所有権とは、Rustのプログラムにおいて、どの部分が特定のデータに対して責任を持つか、という概念です。少し抽象的なので、具体例で考えてみます。
自分が友達に本を貸すとします。この時、本を「所有」しているのは自分です。友達に本を渡した時点で、自分は本を自由に使う権利（所有権）を一時的に友達に譲渡します。友達が本を読み終わって返してくれれば、所有権は再び自分に戻ってきます。
Rustの所有権も、これと似たような考え方ですが、より厳密なルールが適用されます。Rustでは、変数があるデータを所有し、そのデータの使用や解放に対する責任を持ちます。そして、所有権が移動すると、元の変数は無効になります。

 スタックとヒープ所有権を理解するためには、メモリの「スタック」と「ヒープ」という2つの領域についても知っておく必要があります。

スタック: サイズが固定されたデータを格納するのに適しています。関数呼び出し時のローカル変数などがここに格納されます。スタックは高速にアクセスできますが、サイズがコンパイル時に決まっている必要があります。

ヒープ: サイズが動的に変化するデータを格納するのに適しています。String型のように、実行時にサイズが変わる可能性があるデータはヒープに格納されます。ヒープはスタックよりもアクセスが遅いですが、柔軟性があります。

 Rustの所有権ルールの3原則Rustの所有権システムは、以下の3つの原則に基づいています。
各値は、所有者と呼ばれる変数を1つだけ持つ。
所有者は同時に1つしか存在できない。
所有者がスコープから外れると、値はドロップ（解放）される。
これらのルールにより、Rustはメモリ安全性を保証しています。

 スコープと所有権変数のスコープ（有効範囲）は、所有権と密接に関係しています。変数がスコープから外れると、その変数が所有していたデータは自動的に解放（ドロップ）されます。
fn main() {
    { // s はここから有効になる
        let s = String::from("hello"); // s は "hello" という文字列を所有する

        // s を使った処理...
        println!("{}", s);
    } // このスコープが終わり、s は無効になる。s が所有していたメモリは解放される
}
この例では、sは内側のスコープ内でString型の値を所有しています。スコープの終わりで、sは無効になり、String型の値は自動的に解放されます。これは、Rustの所有権ルール3に基づいています。

 ムーブ (Move)Rustでは、変数間でデータをやり取りする際に「ムーブ」という概念が重要になります。ムーブは、値の所有権をある変数から別の変数へ移動させることを指します。
詳細な挙動:

所有権の移動: ムーブが発生すると、元の変数は無効になり、その変数を使おうとするとコンパイルエラーになります。

浅いコピー(Shallow Copy)と無効化: ムーブでは、データのポインタ、長さ、容量などのメタデータ（String型の場合は、ヒープ領域へのポインタ、文字列の長さ、容量）が、スタック上でコピーされます。データ本体はコピーされません。そして、元の変数は無効化されます（具体的には、コンパイラが元の変数の使用を禁止します）。これにより、同じヒープ領域のデータを指す有効な変数が複数存在することを防ぎ、メモリ安全性を保証します。

パフォーマンスへの影響: ムーブは、データのディープコピーを避けるため、一般的に非常に高速な操作です。
注意点:

意図しないムーブ: 関数の引数に値を渡す際や、変数への代入時に注意が必要です。

ムーブ後の変数使用: ムーブが発生した後に元の変数を使用しようとすると、コンパイルエラーになります。
fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // s1 の所有権が s2 にムーブする

    // println!("{}", s1); // これはエラー！s1 はもう有効ではない
    println!("{}", s2);

    let s3 = String::from("world");
    take_ownership(s3); // s3から関数へムーブ
    // println!("{}", s3); // コンパイルエラー: value borrowed here after move
}

fn take_ownership(some_string: String) {
    println!("{}", some_string);
}

 よくある間違い：ムーブ後の変数使用よくある間違いの一つは、ムーブ後に元の変数を使用しようとすることです。
fn main() {
    let s1 = String::from("hello");
    let s2 = s1;
    
    println!("s1: {}", s1); // エラー: value borrowed here after move
}
このエラーは、所有権がs1からs2に移動した後、s1を使おうとしているために発生します。
解決方法:
クローンを使用する（後述）
参照（借用）を使用する（後述）
コピートレイトを実装する（基本型のみ）

 クローンデータを複製したい場合は、「クローン」を使用します。
fn main() {
    let s1 = String::from("hello");
    let s2 = s1.clone(); // s1 のデータを複製して s2 に渡す

    println!("s1 = {}, s2 = {}", s1, s2); // これはOK！s1 も s2 も有効
}
cloneメソッドを使うと、データのディープコピー（完全な複製）が作成されます。これにより、s1とs2はそれぞれ独立したデータを所有することになります。
ただし、クローンはコストが高い操作（メモリを多く消費し、処理時間もかかる）であることに注意が必要です。

 コピー一部の型（整数型など）は、Copyトレイトを持っています。Copyトレイトを持つ型は、ムーブではなくコピーが行われます。
fn main() {
    let x = 5;
    let y = x; // x の値が y にコピーされる

    println!("x = {}, y = {}", x, y); // これはOK！x も y も有効
}
整数型などの単純な型は、スタックに格納されるため、コピーのコストが低く、ムーブよりもコピーの方が効率的です。
Copyトレイトを持つ主な型:
整数型（i32, u64など）
浮動小数点型（f32, f64）
真偽値型（bool）
文字型（char）
タプル（すべての要素がCopyトレイトを持つ場合）

 関数と所有権関数への引数渡しと戻り値も、所有権に影響を与えます。
fn take_ownership(some_string: String) { // some_string が所有権を受け取る
    println!("{}", some_string);
} // ここで some_string がドロップされる

fn gives_ownership() -> String { // 所有権を返す関数
    let some_string = String::from("hello");
    some_string // some_string の所有権が呼び出し元に移動する
}

fn main() {
    let s = String::from("hello");
    take_ownership(s); // s の所有権が take_ownership 関数に移動する
    // println!("{}", s); // これはエラー！s はもう有効ではない

    let s2 = gives_ownership(); // gives_ownership から所有権を受け取る
    println!("{}", s2);
}
この例では、take_ownership関数は引数としてString型の所有権を受け取り、関数の終了時にその値をドロップします。一方、gives_ownership関数はString型の所有権を生成し、呼び出し元に返します。

 実践的なユースケース：ファイル操作での所有権所有権の概念は、リソースを適切に管理するために非常に役立ちます。例えば、ファイル操作を考えてみましょう：
use std::fs::File;
use std::io::prelude::*;

fn write_to_file(file_path: &str, content: &str) -> std::io::Result<()> {
    let mut file = File::create(file_path)?; // ファイルの所有権を取得
    file.write_all(content.as_bytes())?;
    Ok(())
} // スコープを抜けると、fileはドロップされ、ファイルは自動的に閉じられる

fn main() -> std::io::Result<()> {
    write_to_file("example.txt", "Hello, Rust!")?;
    // ファイルは既に閉じられているので、リソースリークの心配なし
    Ok(())
}
この例では、file変数がスコープを抜けるとき、ファイルハンドルは自動的に閉じられます。これにより、C言語などでよくある「ファイルを閉じ忘れる」というバグを防ぐことができます。

 借用 (Borrowing)所有権を移動させずにデータにアクセスしたい場合は、「借用」を使います。借用には、以下の2種類があります。

不変の参照 (&T): 読み取り専用の参照。複数の不変の参照を同時に作成できます。

可変の参照 (&mut T): 読み書き可能な参照。ただし、ある時点で存在できる可変の参照は1つだけです。この制限は、データ競合を防ぐために設けられています。データ競合とは、複数のスレッドが同時に同じデータにアクセスし、少なくとも1つのスレッドが書き込みを行う場合に発生する問題です。可変参照の排他性により、Rustはコンパイル時にデータ競合を防止します。
fn calculate_length(s: &String) -> usize { // s は String の参照
    s.len()
} // ここで s はスコープを抜けるが、ドロップはされない（所有権を持っていないため）

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

fn main() {
    let s = String::from("hello");
    let len = calculate_length(&s); // s の参照を渡す
    println!("The length of '{}' is {}.", s, len);

    let mut s2 = String::from("hello");
    change(&mut s2);
    println!("{}", s2);
}
この例では、calculate_length関数はStringの不変の参照を受け取り、長さを計算します。change関数はStringの可変の参照を受け取り、文字列を変更します。
借用を使うことで、所有権を移動せずにデータにアクセスできるため、より柔軟なコードを書くことができます。また、Rustの借用チェッカーが、ダングリングポインタやデータ競合（複数のコードが同時に同じデータを読み書きすることによる予測不能な動作）を防いでくれます。

 よくある間違い：参照規則の違反借用には以下の規則があります：
任意の時点で、1つの可変参照 または 複数の不変参照 のどちらかを持つことができる（両方は持てない）
参照は常に有効でなければならない（ダングリング参照は許されない）
よくある間違い：
fn main() {
    let mut s = String::from("hello");
    
    let r1 = &s; // 不変参照
    let r2 = &s; // 不変参照
    let r3 = &mut s; // 可変参照 - エラー！
    
    println!("{}, {}, and {}", r1, r2, r3);
}
このコードはコンパイルエラーになります。不変参照と可変参照が同時に存在することは許されないためです。
解決方法:
fn main() {
    let mut s = String::from("hello");
    
    {
        let r1 = &s; // 不変参照
        let r2 = &s; // 不変参照
        println!("{} and {}", r1, r2);
    } // r1とr2はここでスコープを抜ける
    
    let r3 = &mut s; // 可変参照 - OK！
    println!("{}", r3);
}

 ドロップ (Drop)値がスコープから外れると、Rustは自動的にdropメソッドを呼び出し、値を解放します。Dropトレイトを実装することで、独自のリソース解放処理を記述できます。
詳細な挙動:

自動呼び出し: Rustコンパイラは、値がスコープから外れると、自動的にdropメソッドを呼び出すコードを挿入します。

dropメソッド: Dropトレイトはdropメソッドを定義します。このメソッドは、&mut selfを引数として受け取り、リソース解放処理を記述します。

RAII (Resource Acquisition Is Initialization): Dropトレイトは、RAIIパターンを実現するための重要な要素です。これは「リソースの確保は初期化時に行い、リソースの解放はオブジェクトの破棄時に自動的に行う」という設計パターンです。

ドロップ順序: 複数の変数が同じスコープ内で定義されている場合、定義された順序と逆の順序でドロップされます。これは、変数が他の変数への参照を持っている可能性があるためです。先に定義された変数が、後に定義された変数への参照を持っている場合、先に定義された変数を先にドロップしてしまうと、ダングリングポインタが発生する可能性があります。そのため、Rustは定義と逆順にドロップすることで、この問題を回避します。
注意点:

dropメソッドの明示的呼び出し: 通常、dropメソッドを明示的に呼び出す必要はありません。

循環参照: スマートポインタ（RcやArc）を使用する場合、循環参照に注意が必要です。

ドロップ順序: 上記参照
struct MyResource {
    data: String,
}

impl Drop for MyResource {
    fn drop(&mut self) {
        println!("Dropping MyResource with data: {}", self.data);
        // ここでリソース解放処理を行う（例：ファイルクローズ）
    }
}

fn main() {
    let resource = MyResource { data: String::from("example") };
    // resourceを使った処理...
    let resource1 = MyResource { data: String::from("resource 1") };
    let resource2 = MyResource { data: String::from("resource 2") };
} // ここでresourceがスコープから外れ、dropメソッドが自動的に呼び出される。resource2, resource1の順でドロップ

 スライス型所有権と並んで重要な概念であるスライス型について説明します。スライスは、コレクション全体ではなく、コレクションの一部への参照を可能にする機能です。

 スライス型とは？スライスとは、コレクションの一部分を参照するデータ型です。スライスは所有権を持たず、参照として機能します。つまり、データをコピーすることなく、コレクションの連続した要素の範囲にアクセスできます。
最も一般的なスライスの例として、文字列スライス (&str) があります。これは、String の一部または全体への参照です。

 文字列スライス文字列スライスは、String の一部分を参照するのに役立ちます。
fn main() {
    let s = String::from("hello world");

    let hello = &s[0..5]; // "hello"への参照
    let world = &s[6..11]; // "world"への参照

    println!("{} {}", hello, world);
}
この例では、&s[0..5] は文字列 s の最初から5文字目までのスライスを作成します。スライスの範囲は [開始インデックス..終了インデックス] の形式で指定し、終了インデックスの位置は含まれません。
スライスの範囲指定には便利な省略形もあります：
let s = String::from("hello");

// 以下はすべて同じ
let slice1 = &s[0..5];
let slice2 = &s[..5];   // 先頭からなら0は省略可能
let slice3 = &s[0..];   // 末尾までなら長さは省略可能
let slice4 = &s[..];    // 文字列全体のスライス

 文字列リテラルはスライス (&str)Rustの文字列リテラル "hello" は実は文字列スライス型 &str です。これはコンパイル時に値がわかっており、変更できないため、バイナリの特定の位置にある文字列への参照として扱われます。
let s = "Hello, world!"; // s: &str

 文字列スライスを引数にとる関数 (&str vs &String)文字列処理関数を書く場合、&String の代わりに &str を引数にすると柔軟性が増します。
fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let my_string = String::from("hello world");

    // String型の値から関数を呼び出せる
    let word = first_word(&my_string);

    // 文字列リテラルでも同じ関数が使える
    let my_string_literal = "hello world";
    let word = first_word(my_string_literal);
}
この関数は文字列の最初の単語を返します。引数を &str にすることで、String 型と文字列リテラル (&str) の両方を受け付けることができます。

 その他のスライススライスは文字列だけでなく、配列などの他のコレクションにも適用できます。
fn main() {
    let a = [1, 2, 3, 4, 5];

    let slice = &a[1..3]; // [2, 3]へのスライス

    assert_eq!(slice, &[2, 3]);
}
この例では、&[i32] 型の配列スライスを作成しています。

 スライスの安全性スライスはRustの安全性を高める重要な機能です。以下は文字列処理における一般的な問題をスライスで解決する例です：
fn main() {
    let mut s = String::from("hello world");

    let word = first_word(&s); // "hello"への参照を取得

    s.clear(); // この行はコンパイルエラーになる！

    // word はまだ s の一部を参照しているため、s を変更することはできない
    println!("the first word is: {}", word);
}
このコードはコンパイルエラーになります。なぜなら、不変の参照 word が有効である間に、可変の参照 s.clear() を作成しようとしているからです。これは借用規則の違反です。このようにして、Rustはスライスを使用する場合でも安全性を保証します。

 スライスのメリットスライスには以下のようなメリットがあります：

所有権を移動せずにデータにアクセスできる: データの一部を参照するだけで、所有権を気にする必要がありません。

メモリ効率: データをコピーせず参照するだけなので、メモリ効率が良いです。

安全性: コンパイル時にスライスの有効性がチェックされるため、範囲外アクセスなどの問題を防げます。

柔軟性: &str を引数に取る関数は、String と文字列リテラル (&str) の両方を受け入れられます。
スライスはRustの所有権システムと組み合わせることで、安全かつ効率的なプログラミングを可能にします。特に文字列処理において、スライスの理解は非常に重要です。

 まとめ所有権は、Rustのメモリ安全性を根本から支える大切な仕組みです。実際にコードを書いてみると、最初は戸惑う瞬間があるかもしれません。しかし慣れてくると、コンパイラが安全性を保証してくれる心強さが実感できるので、学習が進むほど「この仕組みのおかげでバグを未然に防げるんだ」と納得感が増していきます。
また、所有権を深く理解するには、ライフタイム（参照が有効なスコープと期間）の概念が欠かせません。ライフタイムは所有権と密接に関連しており、複雑な関数同士のやり取りや構造体内の参照を扱う場合でもメモリ安全を維持するために重要です。今後はライフタイムの学習も進めながら、借用チェックの仕組みがどのように機能しているかをさらに理解していきたいと思います。

 参考資料The Rust Programming Language 日本語版
Rustの所有権に入門した

はじめに

所有権とは？

スタックとヒープ

Rustの所有権ルールの3原則

スコープと所有権

ムーブ (Move)

よくある間違い：ムーブ後の変数使用

クローン

コピー

関数と所有権

実践的なユースケース：ファイル操作での所有権

借用 (Borrowing)

よくある間違い：参照規則の違反

ドロップ (Drop)

スライス型

スライス型とは？

文字列スライス

文字列リテラルはスライス (`&str`)

文字列スライスを引数にとる関数 (`&str` vs `&String`)

その他のスライス

スライスの安全性

スライスのメリット

まとめ

参考資料

Discussion
