MENU
  1. ホーム
  2. Rust
  3. Rustで所有権を移動させずに値を操作する方法を詳しく解説

Rustで所有権を移動させずに値を操作する方法を詳しく解説

Rust

Rustはその革新的な所有権システムによって、メモリ管理の効率化と安全性を両立しています。しかし、所有権のルールが厳格であるため、初心者にとっては値を操作する際に制約を感じることもあります。本記事では、Rustにおける所有権の移動を回避しつつ、値を操作するためのテクニックを詳しく解説します。これにより、効率的かつ安全にRustプログラムを開発するスキルを習得できます。

目次
  1. Rustの所有権システムの基本
    1. 所有権の基本ルール
    2. 所有権の移動（ムーブ）
    3. 所有権システムのメリット
  2. 借用とリファレンスの基礎
    1. 借用とは何か
    2. リファレンスのルール
    3. 不変リファレンス
    4. 可変リファレンス
    5. 借用の活用例
  3. ミュータブル借用の活用法
    1. ミュータブル借用の基本
    2. ミュータブル借用のルール
    3. 活用例：データ構造の操作
    4. 注意点
  4. スライスとデータ操作
    1. スライスとは何か
    2. スライスの種類
    3. スライスの利点
    4. 応用例：スライスでの操作
    5. 注意点
  5. 所有権を移動させないコピーとクローンの違い
    1. `Copy`トレイト
    2. `Clone`トレイト
    3. `Copy`と`Clone`の違い
    4. 適切な選択の基準
  6. ライフタイム注釈の役割
    1. ライフタイムとは何か
    2. ライフタイム注釈の基本構文
    3. ライフタイム注釈が必要な場合
    4. ライフタイム注釈の利点
    5. 応用例：複雑な関数のライフタイム管理
    6. 注意点
  7. 値の所有権を保持する関数のデザイン
    1. 所有権を保持する関数の設計原則
    2. リファレンスを活用した例
    3. 戻り値で所有権を移動させない設計
    4. 所有権を返す場合の工夫
    5. 組み合わせた関数設計
    6. 注意点
  8. 応用例：複雑なデータ構造の操作
    1. 例1：構造体のフィールドを操作する
    2. 例2：ネストしたデータ構造の操作
    3. 例3：イミュータブル借用を使った並列アクセス
    4. 例4：所有権を保持した反復処理
    5. 注意点
  9. 演習問題で理解を深める
    1. 問題1: 所有権の移動を理解する
    2. 問題2: リファレンスを使った関数
    3. 問題3: スライスを使った単語分割
    4. 問題4: ライフタイム注釈
    5. 問題5: ミュータブル借用の応用
    6. 解答例
  10. まとめ

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


Rustの所有権システムは、メモリ安全性を保証するためのコア機能であり、言語の特徴の一つです。このシステムでは、各値に所有者が1つだけ存在し、所有者がスコープを外れるとその値のメモリが解放されます。

所有権の基本ルール

  1. 各値は1つの所有者を持つ。
  2. 所有者がスコープを外れると値は自動的にドロップされる。
  3. 所有権を他の変数に移すと、元の変数は値にアクセスできなくなる（ムーブ）。

所有権の移動（ムーブ）


以下のコードは、所有権がどのように移動するかを示しています：

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // 所有権がs1からs2にムーブ
    // println!("{}", s1); // ここでエラーが発生
}

s1の所有権がs2に移動するため、s1は無効となりアクセスできなくなります。

所有権システムのメリット

  • メモリ安全性：手動でメモリを管理する必要がなく、ダングリングポインタや二重解放エラーを防げます。
  • パフォーマンス：ガベージコレクションが不要で、高速な実行が可能です。

所有権システムの基礎を理解することは、Rustを効率的に活用するための第一歩です。次節では、所有権を移動させずに値を操作する「借用」と「リファレンス」について解説します。

借用とリファレンスの基礎


所有権を移動させずに値を操作するために、Rustでは「借用」と「リファレンス」を使用します。これにより、所有権を保持しつつ、他のスコープから値にアクセスできるようになります。

借用とは何か


借用とは、所有権を移動させずに値を参照する仕組みです。これを実現するのがリファレンスです。リファレンスは、参照先の所有権を保持せず、アクセスのみを許可します。

例：リファレンスを使用した借用

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1); // 借用
    println!("The length of '{}' is {}.", s1, len); // s1はそのまま使える
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

&s1がs1を借用しており、calculate_length関数内でs1の所有権を移動させることなく使用しています。

リファレンスのルール

  1. 任意のタイミングで、複数の不変リファレンスか1つの可変リファレンスのどちらかのみが許可される。
  2. リファレンスはデフォルトで不変である。

不変リファレンス


不変リファレンスでは値を変更することはできません。以下はその例です：

fn main() {
    let s1 = String::from("hello");
    let r1 = &s1; // 不変リファレンス
    println!("{}", r1);
    // r1を使ってs1を変更することはできません
}

可変リファレンス


可変リファレンスを使用することで、値を変更できます。ただし、同時に複数の可変リファレンスを持つことはできません：

fn main() {
    let mut s = String::from("hello");
    let r1 = &mut s; // 可変リファレンス
    r1.push_str(", world");
    println!("{}", r1);
}

借用の活用例


借用とリファレンスを使うことで、所有権を複数の箇所で同時に扱うことが可能になり、コードの柔軟性が高まります。所有権の移動を避けたい場合は、この方法が非常に有効です。

次節では、可変リファレンスをより深く理解し、効率的に利用する方法について解説します。

ミュータブル借用の活用法


Rustではミュータブル借用（可変リファレンス）を使うことで、所有権を移動させることなく値を変更することができます。これにより、所有権ルールを守りながら効率的なデータ操作が可能になります。

ミュータブル借用の基本


ミュータブル借用を作成するには、リファレンスと同様に&を使用しますが、借用先の変数とリファレンスの両方にmutをつける必要があります。

例：ミュータブル借用の基本例

fn main() {
    let mut s = String::from("hello");
    modify_string(&mut s); // ミュータブル借用
    println!("{}", s); // sが変更されている
}

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

この例では、modify_string関数が&mut sを借用し、sの内容を直接変更しています。

ミュータブル借用のルール

  1. 同時に複数の可変リファレンスを作成することはできない。
  2. 可変リファレンスが存在する間は、不変リファレンスも作成できない。

これらのルールにより、データ競合が防止され、メモリ安全性が保証されます。

例：複数のミュータブル借用はエラーになる

fn main() {
    let mut s = String::from("hello");
    let r1 = &mut s;
    let r2 = &mut s; // エラー
    r1.push_str(", world");
    r2.push_str("!");
}

このコードは、同時に2つのミュータブル借用を持とうとしてエラーになります。

活用例：データ構造の操作


複雑なデータ構造を操作する際にも、ミュータブル借用は非常に便利です。例えば、ベクタの要素を変更する場合：

fn main() {
    let mut numbers = vec![1, 2, 3];
    update_vector(&mut numbers);
    println!("{:?}", numbers);
}

fn update_vector(vec: &mut Vec<i32>) {
    vec.push(4);
    vec[0] = 10;
}

この例では、ベクタをミュータブル借用することで、所有権を移動させることなく要素を変更できます。

注意点


ミュータブル借用は便利ですが、使用中のリファレンスが他のスコープで誤って使われないよう、ライフタイムやスコープの管理に注意する必要があります。

次節では、スライスを活用してデータを効率的に操作する方法を紹介します。

スライスとデータ操作


Rustではスライスを使用することで、所有権を移動させずにデータの一部分にアクセスできます。スライスはデータ操作を効率化し、所有権の制約を回避する強力なツールです。

スライスとは何か


スライスはコレクションの一部を指すリファレンスです。スライスは所有権を持たず、元のデータに対する部分的なアクセスを可能にします。

例：文字列スライス

fn main() {
    let s = String::from("hello world");
    let hello = &s[0..5]; // "hello"を指すスライス
    let world = &s[6..11]; // "world"を指すスライス
    println!("{} {}", hello, world);
}

このコードでは、helloとworldが元の文字列のスライスであり、所有権を移動させずに部分データを操作しています。

スライスの種類

文字列スライス


文字列スライスは、String型や文字列リテラルの一部を参照します。

fn main() {
    let s = String::from("Rust programming");
    let slice = &s[5..16]; // "programming"
    println!("{}", slice);
}

配列スライス


配列の一部にもスライスを使用できます。

fn main() {
    let numbers = [1, 2, 3, 4, 5];
    let slice = &numbers[1..4]; // [2, 3, 4]
    println!("{:?}", slice);
}

スライスの利点

  1. 所有権を保持：元のデータの所有権を移動させずに部分的に操作できる。
  2. 効率的な操作：大きなデータ構造の一部だけを操作可能。
  3. 安全性：範囲外アクセスがコンパイル時に検出される。

応用例：スライスでの操作


スライスを活用すると、文字列操作が効率化されます。以下は単語の分割を行う例です：

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 s = String::from("hello world");
    let word = first_word(&s);
    println!("{}", word); // "hello"
}

注意点


スライスは元のデータが有効である間のみ使用可能です。スライスのライフタイムが元のデータよりも長くならないように注意する必要があります。

次節では、所有権を移動させないデータコピーの方法として、CopyとCloneの違いについて解説します。

所有権を移動させないコピーとクローンの違い


Rustでは、所有権を移動させずにデータを複製する方法として、CopyとCloneの2つの仕組みがあります。それぞれの特徴を理解し、適切に使い分けることが重要です。

`Copy`トレイト


Copyトレイトを持つ型は、所有権を移動させずにその値をビット単位で複製できます。Copyは、軽量なデータ型（整数や浮動小数点数など）に適しています。

例：Copyトレイトの利用

fn main() {
    let x = 42; // `i32`は`Copy`を実装している
    let y = x;  // 所有権を移動せず、値が複製される
    println!("x: {}, y: {}", x, y); // 両方の変数を使用可能
}

この場合、xの所有権は移動せず、値がそのままyにコピーされます。

`Copy`が利用できる型

  • 整数型（i32, u8など）
  • 浮動小数点型（f32, f64）
  • bool型、char型
  • ポインタ（&Tなど）

`Clone`トレイト


Cloneトレイトを持つ型では、より複雑なデータ構造を明示的に複製できます。Cloneは、深いコピー（ヒープ領域のデータも含めた複製）を行うことができます。

例：Cloneトレイトの利用

fn main() {
    let s1 = String::from("hello");
    let s2 = s1.clone(); // `Clone`による複製
    println!("s1: {}, s2: {}", s1, s2); // 両方の変数を使用可能
}

このコードでは、s1の所有権を移動させるのではなく、新しいメモリ領域を確保してs2が作成されています。

`Clone`の特徴

  • Copyよりもコストが高い（ヒープ領域のデータも複製するため）。
  • 明示的に呼び出す必要がある（clone()メソッドを使用）。

`Copy`と`Clone`の違い

特徴CopyClone
複製の深さ浅いコピー（ビット単位）深いコピー（全データ）
実行コスト軽量高コスト（場合による）
呼び出し方法自動明示的（clone()）
適用される型プリミティブ型など軽量型ヒープデータを含む型

適切な選択の基準

  • 軽量な型（整数型やポインタ型）：Copyが適している。
  • ヒープメモリを含む複雑な型：Cloneを使用して深いコピーを行う。

次節では、データのライフタイムを管理するための重要な概念であるライフタイム注釈について詳しく解説します。

ライフタイム注釈の役割


Rustでは、ライフタイム注釈を使用してリファレンスが有効な期間を明示的に指定します。これにより、所有権と借用のルールを守りながら、安全にコードを記述できます。

ライフタイムとは何か


ライフタイムとは、リファレンスが有効である期間のことです。Rustの所有権システムは、コンパイル時にライフタイムを検証し、無効なリファレンスが使用されることを防ぎます。

例：ライフタイムの検証

fn main() {
    let r;
    {
        let x = 5;
        r = &x; // エラー: xのライフタイムが終了する
    }
    println!("{}", r);
}

この例では、xのライフタイムがスコープを抜けると終了するため、rは無効なリファレンスとなりコンパイルエラーになります。

ライフタイム注釈の基本構文


ライフタイム注釈は、'aのようにアポストロフィで始まるシンボルを使用します。これは、複数のリファレンス間のライフタイム関係を明示するために使用されます。

例：ライフタイム注釈

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

fn main() {
    let string1 = String::from("long string");
    let string2 = "short";
    let result = longest(&string1, string2);
    println!("The longest string is {}", result);
}

この例では、'aがx、y、および戻り値のリファレンスのライフタイムを結びつけています。

ライフタイム注釈が必要な場合


ライフタイム注釈は、コンパイラがリファレンスのライフタイムを自動で推論できない場合に必要です。具体的には以下のような場合があります：

  • 関数の引数と戻り値の間に関係がある場合。
  • 複数のリファレンスが関与する場合。

ライフタイム注釈の利点

  1. 安全性の向上：リファレンスの有効期間が明示され、ランタイムエラーを防止します。
  2. コードの明確化：複雑なスコープ関係が明示され、可読性が向上します。

応用例：複雑な関数のライフタイム管理


複数のリファレンスを受け取る関数でライフタイム注釈を活用する例を紹介します：

fn concatenate<'a>(first: &'a str, second: &'a str) -> String {
    format!("{}{}", first, second)
}

fn main() {
    let part1 = "Hello, ";
    let part2 = "world!";
    let result = concatenate(part1, part2);
    println!("{}", result);
}

注意点

  • ライフタイム注釈は、リファレンス間のライフタイム関係を記述するものであり、ライフタイムを延長するものではありません。
  • 必要以上に注釈をつけるとコードが冗長になるため、コンパイラの推論に頼れる場合は注釈を省略しましょう。

次節では、所有権を保持する関数設計のポイントについて解説します。これにより、ライフタイムを考慮した効率的な関数を構築できます。

値の所有権を保持する関数のデザイン


Rustでは、所有権を移動させずに値を操作するためには、関数設計に工夫が必要です。ここでは、所有権を保持しながら効率的に値を操作する方法を解説します。

所有権を保持する関数の設計原則

  1. 借用を活用する：関数に値を渡す際、リファレンスを使用して所有権を移動させない。
  2. 戻り値の所有権に注意：関数が新しい値を生成する場合、所有権を返す必要がある。
  3. ライフタイムの関係を考慮：リファレンスを返す場合、ライフタイム注釈を正しく適用する。

リファレンスを活用した例


関数がリファレンスを受け取り、値を操作する場合の設計例を示します。

例：リファレンスを受け取る関数

fn calculate_length(s: &String) -> usize {
    s.len()
}

fn main() {
    let s = String::from("hello");
    let len = calculate_length(&s); // リファレンスを渡す
    println!("The length of '{}' is {}.", s, len); // 所有権は保持される
}

この関数は、所有権を保持しながら文字列の長さを計算します。

戻り値で所有権を移動させない設計


リファレンスを返すことで所有権の移動を防ぐことができます。ただし、戻り値のライフタイムが呼び出し元のスコープと一致する必要があります。

例：リファレンスを返す関数

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 s = String::from("hello world");
    let word = first_word(&s);
    println!("The first word is '{}'.", word);
}

この関数では、文字列の最初の単語をリファレンスとして返し、所有権を移動させません。

所有権を返す場合の工夫


関数が新しい値を生成する場合は、所有権を返すことで呼び出し元が管理を引き継ぎます。

例：所有権を返す関数

fn create_greeting(name: &str) -> String {
    format!("Hello, {}!", name) // 新しい`String`の所有権を返す
}

fn main() {
    let greeting = create_greeting("Alice");
    println!("{}", greeting); // 所有権は呼び出し元に移動
}

この設計では、生成したデータの所有権が呼び出し元に渡されます。

組み合わせた関数設計


リファレンスを受け取り、所有権を返す関数を設計することで、柔軟性を向上させることができます。

例：借用と所有権の返却の組み合わせ

fn append_exclamation(s: &mut String) {
    s.push('!');
}

fn main() {
    let mut greeting = String::from("Hello");
    append_exclamation(&mut greeting); // ミュータブル借用
    println!("{}", greeting); // "Hello!"
}

注意点

  • ミュータブル借用を使用する際は、同時に他のリファレンスが存在しないことを確認する。
  • 関数間で所有権やライフタイムの関係が複雑にならないように設計する。

次節では、所有権を移動させないまま複雑なデータ構造を操作する方法について実例を交えて解説します。

応用例：複雑なデータ構造の操作


Rustの所有権と借用の仕組みを活用することで、複雑なデータ構造を効率的に操作することができます。ここでは、所有権を移動させずにデータを操作する実例を解説します。

例1：構造体のフィールドを操作する


複雑な構造体のフィールドを借用して操作する方法を紹介します。

例：構造体のフィールドを借用して更新

struct User {
    name: String,
    age: u32,
}

fn update_age(user: &mut User, new_age: u32) {
    user.age = new_age; // ミュータブル借用でフィールドを更新
}

fn main() {
    let mut user = User {
        name: String::from("Alice"),
        age: 30,
    };

    update_age(&mut user, 35); // 所有権を移動させずに操作
    println!("{} is now {} years old.", user.name, user.age);
}

この例では、User構造体のフィールドを借用し、所有権を保持しながらageを更新しています。

例2：ネストしたデータ構造の操作


ネストしたデータ構造も、借用を利用して一部の要素だけを操作することが可能です。

例：ハッシュマップとベクタのネスト

use std::collections::HashMap;

fn add_score(scores: &mut HashMap<String, Vec<i32>>, name: &str, score: i32) {
    scores.entry(name.to_string())
        .or_insert(vec![])
        .push(score); // 借用した値を更新
}

fn main() {
    let mut scores: HashMap<String, Vec<i32>> = HashMap::new();

    add_score(&mut scores, "Alice", 95);
    add_score(&mut scores, "Alice", 87);
    add_score(&mut scores, "Bob", 76);

    println!("{:?}", scores);
}

このコードでは、HashMapに格納されたVecを借用して新しいスコアを追加しています。

例3：イミュータブル借用を使った並列アクセス


イミュータブル借用を使えば、同時に複数のスコープから安全にデータを参照できます。

例：イミュータブル借用でデータを検索

use std::collections::HashMap;

fn get_scores(scores: &HashMap<String, Vec<i32>>, name: &str) -> Option<&Vec<i32>> {
    scores.get(name) // イミュータブル借用で検索
}

fn main() {
    let mut scores: HashMap<String, Vec<i32>> = HashMap::new();
    scores.insert(String::from("Alice"), vec![95, 87]);
    scores.insert(String::from("Bob"), vec![76]);

    if let Some(alice_scores) = get_scores(&scores, "Alice") {
        println!("Alice's scores: {:?}", alice_scores);
    }
}

この例では、HashMapをイミュータブルに借用し、複数の箇所で同時に検索が可能です。

例4：所有権を保持した反復処理


イテレータを利用すると、所有権を移動させずにデータ構造の各要素を操作できます。

例：ベクタの借用で要素を操作

fn print_elements(elements: &[i32]) {
    for &item in elements.iter() {
        println!("{}", item);
    }
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    print_elements(&numbers); // 所有権を移動させずに反復処理
    println!("Original numbers: {:?}", numbers);
}

このコードでは、ベクタの借用を利用して各要素を反復処理しながら元のデータを保持しています。

注意点

  • 借用の範囲が必要以上に広がらないようにスコープを適切に管理する。
  • ネストしたデータ構造では、所有権と借用の関係が複雑になりやすいため、ライフタイムを明示的に管理することが重要です。

次節では、学んだ内容を実際に試せる演習問題を提供し、知識を定着させます。

演習問題で理解を深める


ここでは、これまで学んだRustの所有権、借用、リファレンス、スライス、ライフタイムなどの概念を実践的に理解するための演習問題を提供します。各問題に取り組み、知識を定着させましょう。

問題1: 所有権の移動を理解する


以下のコードを完成させ、所有権の移動とエラーを防ぐ正しい動作を実現してください。

fn main() {
    let s = String::from("Rust");
    let t = s;
    // 修正してsとtの両方を出力できるようにする
    println!("s: {}", s);
    println!("t: {}", t);
}

問題2: リファレンスを使った関数


以下のコードに、借用を利用して文字列の長さを計算するcalculate_length関数を実装してください。

fn calculate_length(s: /* 借用する型を指定 */) -> usize {
    // 実装を記述
}

fn main() {
    let s = String::from("Ownership");
    let len = calculate_length(/* リファレンスを渡す */);
    println!("The length of '{}' is {}.", s, len);
}

問題3: スライスを使った単語分割


以下の関数を完成させ、文字列の最初の単語をスライスで返すようにしてください。

fn first_word(s: &str) -> &str {
    // 実装を記述
}

fn main() {
    let s = String::from("hello world");
    let word = first_word(&s);
    println!("The first word is '{}'.", word);
}

問題4: ライフタイム注釈


以下のコードにライフタイム注釈を追加し、コンパイル可能な状態にしてください。

fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let string1 = String::from("long string");
    let result;
    {
        let string2 = String::from("short");
        result = longest(&string1, &string2);
    }
    println!("The longest string is '{}'.", result);
}

問題5: ミュータブル借用の応用


以下のコードを完成させ、ハッシュマップ内の値を更新する関数を実装してください。

use std::collections::HashMap;

fn update_value(map: &mut HashMap<String, i32>, key: &str, value: i32) {
    // 実装を記述
}

fn main() {
    let mut scores = HashMap::new();
    scores.insert(String::from("Alice"), 10);

    update_value(&mut scores, "Alice", 20);
    println!("{:?}", scores);
}

解答例


コードが完成したら、コンパイルし、動作を確認してください。それぞれの問題は、所有権や借用の理解を深める助けとなります。

次節では、学んだ内容をまとめ、所有権を移動させずに値を操作する手法の重要性を振り返ります。

まとめ


本記事では、Rustの所有権を移動させずに値を操作するための様々な手法について解説しました。Rustの所有権システムはメモリ安全性を保証する一方で、開発者に独自の制約を課します。これを効率的に活用するためには、以下のポイントが重要です：

  • 所有権の基本ルールを理解し、CopyとCloneの違いを把握する。
  • 借用とリファレンスを使い、所有権を移動させずに値を操作する。
  • スライスやライフタイム注釈を活用して、柔軟かつ安全なデータ操作を行う。
  • 構造体や複雑なデータ構造でも、リファレンスを活用して効率的なコードを記述する。

これらの知識を活用すれば、Rustの安全性と効率性を活かしたプログラムを作成するスキルを身につけることができます。引き続き、演習問題や実際のプロジェクトで練習を重ね、Rustの所有権システムをマスターしましょう。

Rust
プログラミング 所有権 Rust

コメント

コメントする

目次
  1. Rustの所有権システムの基本
    1. 所有権の基本ルール
    2. 所有権の移動（ムーブ）
    3. 所有権システムのメリット
  2. 借用とリファレンスの基礎
    1. 借用とは何か
    2. リファレンスのルール
    3. 不変リファレンス
    4. 可変リファレンス
    5. 借用の活用例
  3. ミュータブル借用の活用法
    1. ミュータブル借用の基本
    2. ミュータブル借用のルール
    3. 活用例：データ構造の操作
    4. 注意点
  4. スライスとデータ操作
    1. スライスとは何か
    2. スライスの種類
    3. スライスの利点
    4. 応用例：スライスでの操作
    5. 注意点
  5. 所有権を移動させないコピーとクローンの違い
    1. `Copy`トレイト
    2. `Clone`トレイト
    3. `Copy`と`Clone`の違い
    4. 適切な選択の基準
  6. ライフタイム注釈の役割
    1. ライフタイムとは何か
    2. ライフタイム注釈の基本構文
    3. ライフタイム注釈が必要な場合
    4. ライフタイム注釈の利点
    5. 応用例：複雑な関数のライフタイム管理
    6. 注意点
  7. 値の所有権を保持する関数のデザイン
    1. 所有権を保持する関数の設計原則
    2. リファレンスを活用した例
    3. 戻り値で所有権を移動させない設計
    4. 所有権を返す場合の工夫
    5. 組み合わせた関数設計
    6. 注意点
  8. 応用例：複雑なデータ構造の操作
    1. 例1：構造体のフィールドを操作する
    2. 例2：ネストしたデータ構造の操作
    3. 例3：イミュータブル借用を使った並列アクセス
    4. 例4：所有権を保持した反復処理
    5. 注意点
  9. 演習問題で理解を深める
    1. 問題1: 所有権の移動を理解する
    2. 問題2: リファレンスを使った関数
    3. 問題3: スライスを使った単語分割
    4. 問題4: ライフタイム注釈
    5. 問題5: ミュータブル借用の応用
    6. 解答例
  10. まとめ