MENU
  1. ホーム
  2. Rust
  3. Rustの所有権設計でメモリ安全性エラーを修正する方法

Rustの所有権設計でメモリ安全性エラーを修正する方法

Rust

Rustの所有権システムは、メモリ安全性を保証するために設計されたプログラム言語の革新的な機能の一つです。このシステムは、データの所有者を明確にし、メモリリークやデータ競合など、プログラムの動作を不安定にする問題を防ぎます。しかし、所有権の仕組みに慣れていないと、プログラムを記述する際にエラーが頻発し、理解が難しいと感じることもあります。本記事では、Rustの所有権設計の基本から、エラーの種類とその修正方法、さらには所有権を活用した応用例まで、実践的な内容を交えながら解説します。これにより、Rustの所有権を効果的に理解し、安全で効率的なプログラム作成のスキルを身につけることができます。

目次
  1. Rustの所有権システムの基礎
    1. 所有権とは何か
    2. 所有権システムの目的
    3. 所有権とスコープ
  2. メモリ安全性の重要性
    1. メモリ安全性とは
    2. Rustがメモリ安全性を保証する仕組み
    3. 実例：所有権によるメモリ安全性の保証
    4. メモリ安全性を意識した設計の重要性
  3. 所有権とライフタイムの関係
    1. ライフタイムとは何か
    2. 所有権とライフタイムの相互作用
    3. ライフタイム注釈
    4. ライフタイムが解決する課題
    5. 実践的なメリット
  4. 所有権エラーの種類と原因
    1. 代表的な所有権エラー
    2. 所有権エラーの主な原因
    3. エラー発生時のメッセージと対処法
    4. 所有権エラーを正しく扱う重要性
  5. 所有権エラーの解消方法
    1. 所有権の移動を防ぐ方法
    2. 可変参照を活用する
    3. ライフタイムを考慮した設計
    4. CloneやCopyを活用する
    5. 関数と所有権の扱い
    6. 所有権エラーへのアプローチのまとめ
  6. 借用と参照のルール
    1. 借用（Borrowing）の基本
    2. 借用ルールの制約
    3. 借用チェッカによる安全性
    4. ライフタイムと借用
    5. 借用と参照の実践的な活用
  7. 所有権設計の応用例
    1. 例1: ファイル操作と所有権
    2. 例2: スレッド間での所有権移動
    3. 例3: データ構造と所有権
    4. 例4: 所有権とエラー処理の統合
    5. まとめ
  8. 所有権エラーを防ぐコーディングのヒント
    1. 1. 借用を優先的に使用する
    2. 2. スコープを短く保つ
    3. 3. 可変参照は慎重に使用する
    4. 4. `Clone`や`Copy`で所有権移動を回避
    5. 5. エラーメッセージを活用する
    6. 6. ライフタイムを意識する
    7. 7. 小さい単位でテストする
    8. まとめ
  9. まとめ

Rustの所有権システムの基礎


Rustの所有権システムは、プログラムのメモリ管理を安全かつ効率的に行うための中心的な仕組みです。このシステムは、他の言語で一般的なガベージコレクタを使用せずに、コンパイル時にメモリの割り当てと解放を管理します。

所有権とは何か


所有権とは、プログラム内の各データが「誰に属しているか」を明確にする概念です。Rustでは、次の三つのルールに基づいて所有権が管理されます：

  1. 各値には所有者が一つだけ存在する
  2. 所有者がスコープを外れると値は自動的に破棄される
  3. 所有権は移動（move）または借用（borrow）によって制御される

所有権システムの目的


所有権システムの主な目的は、以下のような問題を防ぐことです：

  • メモリリーク：メモリが正しく解放されないことによる問題
  • データ競合：複数のスレッドが同じデータにアクセスして発生するエラー
  • ダングリングポインタ：解放されたメモリ領域への無効なアクセス

所有権とスコープ


所有権の管理はスコープに密接に関連しています。変数がスコープに入るときに値が所有され、スコープを外れるとその値は解放されます。
以下に簡単な例を示します：

fn main() {
    let x = String::from("Rust"); // xが所有者
    println!("{}", x);            // xはここで利用可能
} // xがスコープを外れると、メモリが解放される

Rustの所有権システムは、安全で効率的なコード作成の基盤を提供します。この基本を理解することが、Rustプログラミングの第一歩となります。

メモリ安全性の重要性


Rustの所有権システムは、メモリ安全性を保証するために設計されています。これにより、プログラムの信頼性が向上し、バグの発生を大幅に減らすことができます。メモリ管理を自動化しながらも、ガベージコレクタを使わないという特徴は、Rustのパフォーマンスと安全性の両立を実現しています。

メモリ安全性とは


メモリ安全性とは、プログラムがメモリ管理において以下のような問題を防ぐことを指します：

  • ダングリングポインタ：既に解放されたメモリ領域へのアクセス
  • バッファオーバーフロー：メモリの境界を超えた不正な書き込みや読み取り
  • データ競合：複数のスレッドが同時に同じデータを変更することによるエラー

Rustがメモリ安全性を保証する仕組み


Rustでは、コンパイル時に所有権と借用のルールを検証することで、プログラムの実行中に発生しうる多くのメモリ関連のエラーを未然に防ぎます。以下の特徴がメモリ安全性を支えています：

  • 所有権システム：データの所有者が1つであることを保証し、不正なメモリアクセスを防ぎます。
  • 借用チェッカ：借用（mutableまたはimmutable）がルールに従っているかをチェックします。
  • ライフタイム：変数の有効期間をコンパイル時に検証し、ダングリングポインタを防ぎます。

実例：所有権によるメモリ安全性の保証


以下のコード例では、Rustが所有権システムを通じて安全性をどのように保証するかを示しています：

fn main() {
    let s1 = String::from("Rust");
    let s2 = s1; // 所有権がs1からs2に移動する
    // println!("{}", s1); // エラー：s1は無効
    println!("{}", s2); // s2は有効
}

このように、所有権が明確であるため、解放されたデータにアクセスするエラーが防止されます。

メモリ安全性を意識した設計の重要性


メモリ安全性は、特にシステムプログラミングやパフォーマンスが重視される分野で重要です。Rustの所有権システムは、安全性と効率性のトレードオフをなくし、開発者が安心して高性能なプログラムを記述できる環境を提供します。

所有権とライフタイムの関係


Rustの所有権システムを深く理解するには、ライフタイムの概念を把握することが不可欠です。所有権とライフタイムは密接に関連しており、この2つを効果的に扱うことで、安全で効率的なコードを書くことができます。

ライフタイムとは何か


ライフタイムとは、変数や参照が有効である期間を指します。Rustでは、すべての参照にはライフタイムが割り当てられ、コンパイラがその有効範囲を検証します。この仕組みは、ダングリングポインタのようなエラーを防ぐために重要です。

ライフタイムの基本ルール

  1. 参照は有効なデータを指している必要がある
  2. 借用（参照）が有効である間は、データの所有権は移動できない
  3. 可変参照は同時に1つしか存在できない

所有権とライフタイムの相互作用


所有権がスコープを外れると、そのデータは解放されます。しかし、借用が存在する場合、ライフタイムの検証により、参照が不正にならないことをコンパイラが保証します。

例を挙げて説明します：

fn main() {
    let x = 42; // xの所有権はここで定義される
    let r = &x; // xの参照をrに借用
    println!("{}", r); // rはxがスコープ内にある限り有効
} // xがスコープ外になるため、rも無効

ライフタイム注釈


関数や構造体で参照を扱う際、ライフタイム注釈を使う必要がある場合があります。これにより、コンパイラがライフタイムの関係を理解できるようになります。

以下の例では、関数にライフタイム注釈を追加しています：

fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}

このコードは、s1とs2のライフタイムが一致していることを保証します。

ライフタイムが解決する課題


ライフタイムによって解決される代表的な問題：

  • ダングリング参照の防止
  • スレッドセーフなコードの保証
  • 複雑なデータ構造の安全な操作

実践的なメリット


Rustのライフタイム管理は、安全性を高めるだけでなく、開発者がメモリ管理を意識する負担を軽減します。このシステムを理解することで、効率的なプログラム設計が可能になります。

所有権エラーの種類と原因


Rustの所有権システムは、安全性を保つために強力なルールを持っています。しかし、所有権や借用に関連するエラーが発生することがあります。これらのエラーを正しく理解することで、より効率的にエラーを修正できるようになります。

代表的な所有権エラー

  1. 所有権の移動によるエラー
    所有権が他の変数に移動した後、元の変数を使用しようとするとエラーが発生します。
   fn main() {
       let s1 = String::from("Rust");
       let s2 = s1; // s1からs2へ所有権が移動
       // println!("{}", s1); // エラー：s1は無効
       println!("{}", s2); // s2は有効
   }
  1. 可変参照と不変参照の競合
    可変参照と不変参照を同時に作成しようとするとエラーが発生します。
   fn main() {
       let mut s = String::from("Rust");
       let r1 = &s;      // 不変参照
       let r2 = &mut s;  // エラー：可変参照は不変参照と同時に存在できない
       println!("{}", r1);
   }
  1. ダングリング参照
    スコープ外になった変数を参照することで発生するエラーです。Rustではこのような参照が許可されません。
   fn main() {
       let r;
       {
           let x = 5;
           r = &x; // エラー：xのスコープが終了後にrを参照する
       }
       println!("{}", r);
   }

所有権エラーの主な原因

  • ルール違反：所有権や借用のルールを無視しようとするコード。
  • スコープの不一致：変数のライフタイムが短すぎるために参照が無効になるケース。
  • 誤った設計：データ構造や関数設計における所有権の流れを正しく考慮していない場合。

エラー発生時のメッセージと対処法


Rustのエラーメッセージは非常に詳細で、修正方法のヒントが記載されています。エラーメッセージを確認する際は以下を意識してください：

  1. エラーの原因を特定する
    「borrow of moved value」や「mutable borrow occurs here」など、原因が明確に表示されます。
  2. コードの修正箇所を探す
    Rustコンパイラは修正が必要なコード箇所を具体的に示します。
  3. 所有権ルールに従う
    可変参照、不変参照、所有権移動など、基本ルールを確認しながら修正します。

所有権エラーを正しく扱う重要性


所有権エラーは、Rustの安全性を保つために必要な制約です。これらのエラーを適切に理解し、対処することで、安全で効率的なコードが書けるようになります。Rustのエラーメッセージは初心者にも優しい設計となっているため、エラーを恐れず学習を進めてください。

所有権エラーの解消方法


所有権エラーは、Rustの安全性を支える重要な仕組みの一部ですが、プログラミングの初期段階では困惑することも少なくありません。本セクションでは、所有権エラーを解消するための基本的なアプローチと具体例を示します。

所有権の移動を防ぐ方法


所有権の移動によるエラーを防ぐためには、データを借用（参照）する方法を活用します。これにより、所有権を渡すことなくデータを利用できます。

fn main() {
    let s1 = String::from("Rust");
    let s2 = &s1; // s1を借用（不変参照）
    println!("{}", s1); // s1は有効
    println!("{}", s2); // s2も有効
}

ポイント: 不変参照を使用すると、データを複数回参照可能になります。ただし、変更はできません。

可変参照を活用する


データを変更する必要がある場合は、可変参照を利用します。ただし、同時に複数の可変参照を持つことはできません。

fn main() {
    let mut s = String::from("Rust");
    let r = &mut s; // 可変参照
    r.push_str(" is safe!");
    println!("{}", r); // rを通じてデータを変更
}

ポイント: 可変参照は1つだけに制限されるため、データ競合を防ぎます。

ライフタイムを考慮した設計


ライフタイムエラーを解消するためには、変数の有効範囲を見直す必要があります。以下のようにスコープを調整することで、ライフタイムに関する問題を解消できます。

fn main() {
    let r;
    {
        let x = 5;
        r = x; // xの所有権をrに移動
    }
    println!("{}", r); // エラーなし：所有権が移動しているため安全
}

ポイント: 借用が必要な場合はライフタイム注釈を追加して、参照の有効範囲を明確にします。

CloneやCopyを活用する


場合によっては、所有権を移動させずにデータを複製することで問題を回避できます。

fn main() {
    let s1 = String::from("Rust");
    let s2 = s1.clone(); // s1のデータを複製
    println!("{}", s1); // s1は有効
    println!("{}", s2); // s2も有効
}

ポイント: CloneやCopyは計算コストが発生するため、必要な場合に限定して使用します。

関数と所有権の扱い


関数呼び出しで所有権が移動することが原因でエラーが発生する場合は、参照を使って所有権を維持する設計に変更します。

fn print_message(message: &String) {
    println!("{}", message);
}

fn main() {
    let s = String::from("Rust");
    print_message(&s); // 所有権は移動せず、借用される
    println!("{}", s); // sは依然有効
}

ポイント: 借用を活用することで、関数間のデータ移動を効率化できます。

所有権エラーへのアプローチのまとめ

  • 借用（不変・可変）を活用して所有権移動を防ぐ
  • スコープとライフタイムを意識してコードを設計する
  • 必要に応じてCloneやCopyでデータを複製する
  • 関数設計において参照を活用する

所有権エラーの解消は、Rustの設計思想を深く理解するための大きなステップです。これらの方法を実践することで、安全かつ効率的なプログラムを構築できるようになります。

借用と参照のルール


Rustの借用と参照のルールは、所有権システムの中核をなす重要な概念です。これらのルールを理解することで、メモリ安全性を損なわずにプログラムの柔軟性を高めることができます。

借用（Borrowing）の基本


借用とは、所有権を移動せずにデータを利用する方法です。借用には、不変借用（immutable borrow）と可変借用（mutable borrow）の2種類があります。

不変借用


不変借用では、データを読み取り専用で使用できます。

fn main() {
    let s = String::from("Rust");
    let r = &s; // 不変借用
    println!("{}", r); // rを通じてデータを読み取り
    println!("{}", s); // sも引き続き有効
}

ポイント: 複数の不変借用が同時に可能ですが、データを変更することはできません。

可変借用


可変借用では、データを変更することができますが、同時に1つしか存在できません。

fn main() {
    let mut s = String::from("Rust");
    let r = &mut s; // 可変借用
    r.push_str(" is great!"); // rを通じてデータを変更
    println!("{}", r); // rを利用
}

ポイント: 可変借用が存在する間、不変借用や他の可変借用を作ることはできません。

借用ルールの制約


Rustの借用ルールには以下のような制約があります：

  1. 不変借用と可変借用は同時に存在できない
   fn main() {
       let mut s = String::from("Rust");
       let r1 = &s;    // 不変借用
       let r2 = &mut s; // エラー：可変借用が不変借用と競合
       println!("{}", r1);
   }
  1. 可変借用は1つだけ作成可能
   fn main() {
       let mut s = String::from("Rust");
       let r1 = &mut s;
       let r2 = &mut s; // エラー：複数の可変借用は禁止
   }
  1. 借用の有効範囲
    借用は所有者が有効なスコープ内でのみ機能します。

借用チェッカによる安全性


Rustの借用チェッカは、これらのルールをコンパイル時に検証します。この仕組みにより、データ競合やダングリングポインタなどのエラーを未然に防ぎます。

ライフタイムと借用


借用とライフタイムは密接に関連しています。借用が存在する間、そのデータの所有者は解放されることがありません。以下はライフタイムの例です：

fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}

ライフタイム注釈を使うことで、借用の有効期間を明確にできます。

借用と参照の実践的な活用

  • データを安全に共有するために不変借用を活用する
  • 必要最小限の変更を行うために可変借用を使用する
  • 借用ルールに従い、エラーを回避する設計を行う

借用と参照のルールを正しく理解することで、Rustの所有権システムを効果的に利用し、安全かつ効率的なプログラムを構築できます。

所有権設計の応用例


Rustの所有権設計は、安全性と効率性を両立するだけでなく、実践的なプログラムの構築にも大いに役立ちます。本セクションでは、所有権システムを活用した具体的な応用例を紹介します。

例1: ファイル操作と所有権


Rustでは、所有権を活用することでファイル操作を安全に行えます。

use std::fs::File;
use std::io::{self, Read};

fn read_file_contents(filename: &str) -> io::Result<String> {
    let mut file = File::open(filename)?; // Fileの所有権を取得
    let mut contents = String::new();
    file.read_to_string(&mut contents)?; // ファイル内容を読み込む
    Ok(contents) // 所有権を戻す
}

fn main() {
    match read_file_contents("example.txt") {
        Ok(contents) => println!("{}", contents),
        Err(e) => eprintln!("Error: {}", e),
    }
}

ポイント: Fileの所有権を関数内で管理し、スコープ終了時に自動的にリソースが解放されます。

例2: スレッド間での所有権移動


所有権を移動することで、スレッド間でデータを安全に共有できます。

use std::thread;

fn main() {
    let data = String::from("Rust ownership");
    let handle = thread::spawn(move || {
        println!("{}", data); // 所有権をスレッドに移動
    });

    handle.join().unwrap(); // スレッドが終了するのを待つ
}

ポイント: moveキーワードを使用して、所有権を新しいスレッドに移動します。これにより、データ競合が防止されます。

例3: データ構造と所有権


データ構造内で所有権を効果的に管理することで、安全性が向上します。

struct Book {
    title: String,
    author: String,
}

fn print_book(book: &Book) {
    println!("Title: {}, Author: {}", book.title, book.author);
}

fn main() {
    let book = Book {
        title: String::from("Rust Programming"),
        author: String::from("Steve Klabnik"),
    };

    print_book(&book); // 所有権を渡さずに借用
    println!("{}", book.title); // bookは依然有効
}

ポイント: 関数内で借用を使うことで、データ構造の所有権を保持しつつ利用できます。

例4: 所有権とエラー処理の統合


所有権を活用してエラー処理とリソース管理を統合することができます。

use std::fs::File;
use std::io::{self, Write};

fn write_to_file(filename: &str, content: &str) -> io::Result<()> {
    let mut file = File::create(filename)?; // 所有権を取得
    file.write_all(content.as_bytes())?; // 書き込み処理
    Ok(()) // 所有権がスコープを抜けると自動的にリソースが解放
}

fn main() {
    if let Err(e) = write_to_file("output.txt", "Hello, Rust!") {
        eprintln!("Error: {}", e);
    }
}

ポイント: 所有権を利用して、ファイルのリソースを安全に管理します。

まとめ


所有権設計は、以下の場面で特に有用です：

  • リソース管理（ファイル、ネットワーク接続など）
  • スレッド間でのデータ共有
  • 安全なデータ構造の操作
  • エラー処理とメモリ管理の統合

これらの応用例を活用することで、Rustの所有権設計の強力さを実感できるでしょう。Rustを深く理解し、実践に活かすための基盤として、所有権システムを活用してください。

所有権エラーを防ぐコーディングのヒント


Rustの所有権エラーは、プログラムの安全性を確保するための重要な仕組みですが、初心者にとっては難解に感じることがあります。ここでは、所有権エラーを防ぐためのコーディングのベストプラクティスとヒントを紹介します。

1. 借用を優先的に使用する


所有権を移動させるのではなく、参照（借用）を使うことで多くのエラーを回避できます。不変借用を優先し、必要な場合のみ可変借用を使用してください。

fn print_message(message: &String) {
    println!("{}", message); // 借用により所有権を移動せずにデータを使用
}

fn main() {
    let s = String::from("Hello, Rust!");
    print_message(&s); // 不変借用
    println!("{}", s); // sは依然有効
}

2. スコープを短く保つ


スコープを短く保つことで、借用や所有権に関連する複雑さを軽減できます。スコープの明確化は、エラーの発生を減らし、コードの可読性も向上させます。

fn main() {
    {
        let x = 5; // 短いスコープで所有権を管理
        println!("{}", x);
    } // xはここで解放される
    // println!("{}", x); // エラー：xはスコープ外
}

3. 可変参照は慎重に使用する


可変参照は非常に便利ですが、データ競合のリスクを伴います。同時に1つしか可変参照を持てないルールを意識して設計してください。

fn main() {
    let mut s = String::from("Rust");
    {
        let r = &mut s; // 短いスコープで可変参照を使用
        r.push_str(" is great!");
    } // rがスコープを外れると可変参照が解放される
    println!("{}", s); // sを安全に使用
}

4. `Clone`や`Copy`で所有権移動を回避


所有権移動が問題となる場合は、データを複製して問題を解決することができます。特に軽量なデータ型ではCopyトレイトが有効です。

fn main() {
    let x = 42; // i32はCopyトレイトを実装
    let y = x; // 所有権移動ではなくコピー
    println!("{}", x); // xは依然有効
}

5. エラーメッセージを活用する


Rustのエラーメッセージは非常に分かりやすく、具体的な修正案を提示してくれる場合があります。エラー内容を正確に読み取り、原因を理解して修正しましょう。

error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
help: consider changing this to be a mutable borrow

6. ライフタイムを意識する


特に関数間で参照を扱う際には、ライフタイム注釈を使って参照の有効期間を明示的に管理します。これにより、ダングリングポインタエラーを防げます。

fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}

7. 小さい単位でテストする


関数やモジュールを小さく保つことで、所有権エラーの発生箇所を特定しやすくなります。ユニットテストを活用して問題を早期に発見してください。

まとめ


所有権エラーを防ぐには、以下のポイントを意識してコードを書くことが重要です：

  • 借用を積極的に活用する
  • スコープを短く設計する
  • 可変参照の使用を最小限に抑える
  • CloneやCopyを適切に利用する
  • エラーメッセージを丁寧に読み解く

これらのヒントを実践することで、所有権エラーを未然に防ぎ、安全で効率的なRustプログラムを構築できるようになります。

まとめ


本記事では、Rustにおける所有権システムとそのエラー解消方法について詳細に解説しました。所有権はメモリ安全性を確保し、パフォーマンスと安全性を両立させるための強力な機能です。

  • 所有権の基本: 所有権、借用、ライフタイムのルールを理解することが、安全で効率的なプログラム作成に不可欠です。
  • 所有権エラーの種類と原因: 所有権の移動や借用ルールの違反によって発生するエラーを把握し、適切な方法で解消することが大切です。
  • エラー解消の方法: 借用や可変借用を上手く活用し、ライフタイムの管理や所有権の移動に関して注意を払うことで、エラーを防げます。
  • 応用例: 所有権システムは、ファイル操作やスレッド間でのデータ共有、データ構造の安全な管理に活用できます。
  • コーディングのヒント: 所有権エラーを防ぐために、借用の使用、スコープの管理、CloneやCopyの活用など、ベストプラクティスを実践することが重要です。

Rustの所有権設計を理解し、正しく活用することで、堅牢で効率的なプログラムを作成することができます。Rustの安全性とパフォーマンスを最大限に引き出すために、所有権のルールをしっかりと習得していきましょう。

Rust
Rust メモリ安全性 所有権設計

コメント

コメントする

目次
  1. Rustの所有権システムの基礎
    1. 所有権とは何か
    2. 所有権システムの目的
    3. 所有権とスコープ
  2. メモリ安全性の重要性
    1. メモリ安全性とは
    2. Rustがメモリ安全性を保証する仕組み
    3. 実例：所有権によるメモリ安全性の保証
    4. メモリ安全性を意識した設計の重要性
  3. 所有権とライフタイムの関係
    1. ライフタイムとは何か
    2. 所有権とライフタイムの相互作用
    3. ライフタイム注釈
    4. ライフタイムが解決する課題
    5. 実践的なメリット
  4. 所有権エラーの種類と原因
    1. 代表的な所有権エラー
    2. 所有権エラーの主な原因
    3. エラー発生時のメッセージと対処法
    4. 所有権エラーを正しく扱う重要性
  5. 所有権エラーの解消方法
    1. 所有権の移動を防ぐ方法
    2. 可変参照を活用する
    3. ライフタイムを考慮した設計
    4. CloneやCopyを活用する
    5. 関数と所有権の扱い
    6. 所有権エラーへのアプローチのまとめ
  6. 借用と参照のルール
    1. 借用（Borrowing）の基本
    2. 借用ルールの制約
    3. 借用チェッカによる安全性
    4. ライフタイムと借用
    5. 借用と参照の実践的な活用
  7. 所有権設計の応用例
    1. 例1: ファイル操作と所有権
    2. 例2: スレッド間での所有権移動
    3. 例3: データ構造と所有権
    4. 例4: 所有権とエラー処理の統合
    5. まとめ
  8. 所有権エラーを防ぐコーディングのヒント
    1. 1. 借用を優先的に使用する
    2. 2. スコープを短く保つ
    3. 3. 可変参照は慎重に使用する
    4. 4. `Clone`や`Copy`で所有権移動を回避
    5. 5. エラーメッセージを活用する
    6. 6. ライフタイムを意識する
    7. 7. 小さい単位でテストする
    8. まとめ
  9. まとめ