Rust入門：メモリ安全性を理解する実践ガイド

Rustは、システムプログラミング言語として、メモリ安全性を保証しながら高いパフォーマンスを実現することを目指して設計されました。この記事では、Rustの最も重要な特徴である**所有権（Ownership）と借用（Borrowing）**の概念を、実際のコード例を通じて理解していきます。

C言語やC++の経験がある方は特に、Rustのアプローチの違いを実感できるでしょう。

---

1. Rustとは

Rustは、Mozillaが開発したシステムプログラミング言語で、以下の特徴があります。

• メモリ安全性: コンパイル時にメモリエラーを防ぐ
• 並行性: データ競合を防ぐ仕組みが組み込まれている
• パフォーマンス: C/C++と同等の速度を実現
• ゼロコスト抽象化: 抽象化によるオーバーヘッドがない

1.1 環境の準備

# Rustのインストール（Mac/Linux）
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Rustのインストール（Windows）
# https://rustup.rs/ からインストーラーをダウンロード

# バージョンの確認
rustc --version
cargo --version

# 新しいプロジェクトの作成
cargo new rust-memory-guide
cd rust-memory-guide

2. 変数と不変性

Rustでは、デフォルトで変数は不変（immutable）です。これは、意図しない変更を防ぐための重要な設計決定です。

2.1 基本的な変数

fn main() {
    // 不変変数（デフォルト）
    let x = 5;
    // x = 6; // エラー！不変変数は変更できない
    
    // 可変変数（mutキーワードを使用）
    let mut y = 5;
    y = 6; // OK
    println!("yの値: {}", y);
}

2.2 シャドーイング

fn main() {
    let x = 5;
    let x = x + 1; // 新しい変数xを作成（型を変えることも可能）
    let x = x * 2;
    println!("xの値: {}", x); // 12
    
    // 型を変えることも可能
    let spaces = "   ";
    let spaces = spaces.len(); // usize型になる
    println!("スペースの数: {}", spaces);
}

3. 所有権（Ownership）の基本概念

所有権は、Rustの最も革新的な機能の一つです。各値は、それを「所有する」変数を持ち、その変数がスコープを抜けると値は自動的に解放されます。

3.1 所有権の移動

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // s1の所有権がs2に移動
    // println!("{}", s1); // エラー！s1はもう有効ではない
    
    println!("{}", s2); // OK
}

3.2 関数への所有権の移動

fn take_ownership(s: String) {
    println!("{}", s);
} // ここでsがスコープを抜けるので、メモリが解放される

fn main() {
    let s = String::from("hello");
    take_ownership(s);
    // println!("{}", s); // エラー！sの所有権は移動済み
}

3.3 Copyトレイト（スタックに保存されるデータ）

fn main() {
    let x = 5;
    let y = x; // コピーが作成される（所有権の移動ではない）
    println!("x = {}, y = {}", x, y); // 両方とも有効
    
    // Copyトレイトを実装する型：
    // 整数型、浮動小数点型、bool、char、タプル（全てCopy型の場合のみ）
}

4. 借用（Borrowing）と参照

所有権を移動させるのではなく、値を「借用」することができます。これにより、関数に値を渡しても所有権を失うことがありません。

4.1 不変参照

fn calculate_length(s: &String) -> usize {
    s.len()
} // ここでsはスコープを抜けるが、所有権を持っていないので何も起こらない

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1); // &で参照を渡す
    println!("'{}'の長さは{}です", s1, len); // s1はまだ有効
}

4.2 可変参照

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

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

4.3 借用のルール

Rustの借用には重要なルールがあります：

fn main() {
    let mut s = String::from("hello");
    
    // 可変参照は同時に1つしか持てない
    let r1 = &mut s;
    // let r2 = &mut s; // エラー！
    
    // 不変参照と可変参照は同時に持てない
    let mut s2 = String::from("hello");
    let r1 = &s2;
    let r2 = &s2;
    // let r3 = &mut s2; // エラー！
    
    println!("{}, {}", r1, r2); // r1とr2のスコープが終わる
    let r3 = &mut s2; // これならOK
}

5. スライス（Slice）

スライスは、コレクションの一部分を参照するためのデータ型です。所有権を取らずにデータにアクセスできます。

5.1 文字列スライス

fn first_word(s: &String) -> &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);
    // s.clear(); // エラー！wordが不変参照としてsを借用している
    println!("最初の単語: {}", word);
}

5.2 配列スライス

fn main() {
    let a = [1, 2, 3, 4, 5];
    let slice = &a[1..3]; // [2, 3]
    
    for element in slice.iter() {
        println!("{}", element);
    }
}

6. 構造体と所有権

6.1 構造体の定義と使用

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let user1 = User {
        email: String::from("someone@example.com"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };
    
    println!("ユーザー: {}", user1.username);
}

6.2 構造体のメソッド

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    // 関連関数（静的メソッドのようなもの）
    fn square(size: u32) -> Rectangle {
        Rectangle {
            width: size,
            height: size,
        }
    }
    
    // メソッド（&selfを取る）
    fn area(&self) -> u32 {
        self.width * self.height
    }
    
    // 可変メソッド（&mut selfを取る）
    fn double_size(&mut self) {
        self.width *= 2;
        self.height *= 2;
    }
    
    // 所有権を取るメソッド（selfを取る）
    fn into_tuple(self) -> (u32, u32) {
        (self.width, self.height)
    }
}

fn main() {
    let mut rect = Rectangle {
        width: 30,
        height: 50,
    };
    
    println!("面積: {}", rect.area());
    rect.double_size();
    println!("面積（2倍後）: {}", rect.area());
    
    let square = Rectangle::square(10);
    println!("正方形の面積: {}", square.area());
}

7. エラーハンドリング

Rustには、エラーを処理するための強力な仕組みがあります。

7.1 Result型

use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let f = File::open("hello.txt");
    
    let f = match f {
        Ok(file) => file,
        Err(error) => match error.kind() {
            ErrorKind::NotFound => match File::create("hello.txt") {
                Ok(fc) => fc,
                Err(e) => panic!("ファイルの作成に失敗しました: {:?}", e),
            },
            other_error => {
                panic!("ファイルのオープンに失敗しました: {:?}", other_error)
            }
        },
    };
}

7.2 unwrapとexpect

use std::fs::File;

fn main() {
    // unwrap: Okなら値を返し、Errならパニック
    let f = File::open("hello.txt").unwrap();
    
    // expect: カスタムエラーメッセージ付き
    let f = File::open("hello.txt")
        .expect("hello.txtを開けませんでした");
}

7.3 エラーの伝播

use std::fs::File;
use std::io;
use std::io::Read;

fn read_username_from_file() -> Result<String, io::Error> {
    let mut f = File::open("hello.txt")?; // ?演算子でエラーを伝播
    let mut s = String::new();
    f.read_to_string(&mut s)?;
    Ok(s)
}

fn main() {
    match read_username_from_file() {
        Ok(username) => println!("ユーザー名: {}", username),
        Err(e) => println!("エラー: {}", e),
    }
}

8. コレクション：ベクタ

8.1 ベクタの基本操作

fn main() {
    // ベクタの作成
    let mut v: Vec<i32> = Vec::new();
    v.push(1);
    v.push(2);
    v.push(3);
    
    // マクロを使った作成
    let v2 = vec![1, 2, 3];
    
    // 要素へのアクセス
    let third: &i32 = &v[2]; // インデックスが範囲外ならパニック
    println!("3番目の要素: {}", third);
    
    // 安全なアクセス
    match v.get(2) {
        Some(third) => println!("3番目の要素: {}", third),
        None => println!("要素が存在しません"),
    }
    
    // イテレーション
    for i in &v {
        println!("{}", i);
    }
    
    // 可変イテレーション
    for i in &mut v {
        *i += 50; // 参照外しが必要
    }
}

9. ライフタイム（Lifetime）

ライフタイムは、参照が有効である期間を指定するための機能です。

9.1 ライフタイム注釈の基本

// ライフタイム注釈の例
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("長い文字列");
    {
        let string2 = String::from("xyz");
        let result = longest(string1.as_str(), string2.as_str());
        println!("長い方: {}", result);
    }
}

9.2 構造体のライフタイム

struct ImportantExcerpt<'a> {
    part: &'a str,
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().expect("'.'が見つかりません");
    let i = ImportantExcerpt {
        part: first_sentence,
    };
    println!("{}", i.part);
}

10. 並行プログラミング

Rustは、並行プログラミングにおけるデータ競合をコンパイル時に防ぎます。

10.1 スレッドの作成

use std::thread;
use std::time::Duration;

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("スレッド: {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });
    
    for i in 1..5 {
        println!("メイン: {}", i);
        thread::sleep(Duration::from_millis(1));
    }
    
    handle.join().unwrap();
}

10.2 チャネル（Channel）

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();
    
    thread::spawn(move || {
        let val = String::from("hi");
        tx.send(val).unwrap();
        // println!("val is {}", val); // エラー！所有権が移動済み
    });
    
    let received = rx.recv().unwrap();
    println!("受信: {}", received);
}

10.3 Mutex（相互排他）

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];
    
    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    println!("結果: {}", *counter.lock().unwrap());
}

11. 実践的な例：ファイル読み込みユーティリティ

ここまで学んだ知識を組み合わせて、実用的なプログラムを作成しましょう。

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

struct FileProcessor {
    filename: String,
}

impl FileProcessor {
    fn new(filename: String) -> Self {
        FileProcessor { filename }
    }
    
    fn read_lines(&self) -> Result<Vec<String>, io::Error> {
        let file = File::open(&self.filename)?;
        let reader = BufReader::new(file);
        
        let mut lines = Vec::new();
        for line in reader.lines() {
            lines.push(line?);
        }
        Ok(lines)
    }
    
    fn write_lines(&self, lines: &[String]) -> Result<(), io::Error> {
        let mut file = File::create(&self.filename)?;
        for line in lines {
            writeln!(file, "{}", line)?;
        }
        Ok(())
    }
}

fn main() -> Result<(), io::Error> {
    let processor = FileProcessor::new(String::from("test.txt"));
    
    // ファイルの読み込み
    match processor.read_lines() {
        Ok(lines) => {
            println!("読み込んだ行数: {}", lines.len());
            for (i, line) in lines.iter().enumerate() {
                println!("{}: {}", i + 1, line);
            }
        }
        Err(e) => {
            eprintln!("エラー: {}", e);
            // 新規ファイルを作成
            let new_lines = vec![
                String::from("Hello, Rust!"),
                String::from("これはテストファイルです"),
            ];
            processor.write_lines(&new_lines)?;
        }
    }
    
    Ok(())
}

12. まとめと次のステップ

このガイドを通じて、Rustのメモリ安全性を実現する主要な概念を学びました。

学んだこと

• 所有権（Ownership）: 値の所有権とライフタイムの管理
• 借用（Borrowing）: 参照による値の借用
• スライス: データの一部分への参照
• エラーハンドリング: Result型を使った安全なエラー処理
• 並行プログラミング: スレッド、チャネル、Mutexの使用

Rustのメリット

• メモリ安全性: コンパイル時にメモリエラーを防ぐ
• パフォーマンス: ゼロコスト抽象化による高速実行
• 並行性の安全性: データ競合をコンパイル時に検出
• 実用的: システムプログラミングからWeb開発まで幅広く使用可能

次のステップ

1. Cargoの詳細: 依存関係管理とビルドシステム
2. トレイト（Trait）: インターフェースのような機能
3. ジェネリクス: 汎用的なコードの作成
4. マクロ: メタプログラミング
5. 非同期プログラミング: async/awaitとFuture

Rustは学習曲線が急ですが、その安全性とパフォーマンスは、学習に費やした時間に見合う価値があります。継続的な学習と実践を通じて、Rustの力を最大限に引き出しましょう！

Happy Rusting!