Zenn
😉

[Rust入門] メモリ安全性を理解して、より良いコードを書く

2024/01/03に公開
Rust
#
メモリ管理
tech

前提

※ 私自身、Rustを始めようと思って、開発していく中で色々勉強したことなどを記事としてアウトプットしていこうと思います。

はじめに

プログラミング言語Rustが開発者コミュニティの間で急速に人気を集めている理由は、その独特なメモリ安全性の特性にあります。Rustは、メモリ安全性を保証するための独自のシステムを持ち、プログラマーがより安全で効率的なコードを書くことを可能にします。では、メモリ安全性がプログラミングにおいてなぜこれほど重要なのでしょうか？

メモリ安全性は、プログラムが不正なメモリ操作を行わないことを保証することを意味します。これには、メモリの不正なアクセス、メモリリーク、不適切なメモリ解放などが含まれます。メモリ安全性が確保されていない場合、プログラムは不安定になり、セキュリティリスクが高まる可能性があります。Rustは、所有権の概念、借用チェッカー、ライフタイムといった特徴からこれらの問題を効果的に解決します。

こちらの記事では、Rustのメモリ安全性に関する基本から始めて、その理解を深めることを目指します。所有権、借用、ライフタイムの概念を具体的な例とともに説明し、これらがどのようにしてプログラムの安全性と効率性を向上させるのかを見ていきます。また、Rustが他のプログラミング言語と異なる点や、これらの特性がどのように実世界の問題解決に役立つのかについても探求します。

Rustのメモリ管理の基本

所有権の概念と動作原理

プログラミングにおける「所有権」とは、メモリやリソースを管理するための一つの方法です。Rustでは、この概念が非常に重要で、メモリの安全性と効率を大きく改善します。
所有権の基本的な考え方は下記の3つです。

  1. 変数は値を所有する：Rustでは、各値は一つの変数によって所有されます。その変数がスコープから外れると、値もメモリから解放されます。
  2. 値は一度に一つの所有者しか持てない：同じ値を2つの変数が同時に所有することはできません。これにより、メモリの二重解放やその他のエラーを防ぎます。
    3.所有権の移動：値を別の変数に代入すると、所有権が移動します。例えば、let x = 5; let y = x;とすると、yが5の新しい所有者になります。

下記の例ではsが文字列"hello"の所有者になります。takes_ownership関数にsを渡すと、所有権がsからsome_stringに移動します。関数の実行が終わると、some_stringがスコープを抜け、自動的にメモリが解放されます。

fn main() {
    let s = String::from("hello"); // sが所有権を持つ
    takes_ownership(s);            // sの値が関数に移動
    // ここでsを使用するとエラーになる
}

fn takes_ownership(some_string: String) {
    // some_stringがここで所有権を持つ
    println!("{}", some_string);
} // ここでsome_stringがスコープを抜け、メモリが解放される

借用とライフタイムのルール

所有権の概念に加えて、Rustでは「借用」という強力な概念が導入されています。借用には「不変借用」と「可変借用」の2種類があり、これによりデータへの安全なアクセスが可能になります。不変借用はデータを読むだけで変更はできませんが、可変借用ではデータの変更が許可されます。しかし、可変借用は一度に一つのスコープ内でのみ許可されるため、データ競合を防ぐことができます。また、ライフタイムは、借用されたデータがどのくらいの期間有効であるかを指定するために使用され、不正なメモリアクセスを防ぐのに役立ちます。

上記であったコードでいうとtakes_ownership内ではsの値を変更することはできません。これは先ほど説明した「不変借用」の借用ルールが適用されているためです。

  1. 不変参照（Immutable Reference）：&T型の参照を通じて、値を読むことはできますが、変更することはできません。
  2. 可変参照（Mutable Reference）：&mut T型の参照を通じて、値を読み書きすることができます。

可変参照の場合にのみ、変更が許されるため下記のように変更すると変更が効きます。

fn main() {
    let mut s = String::from("hello");
    takes_ownership(&mut s); // 可変の参照を渡す
    println!("In main: {}", s); // 変更後のsを使用
}

fn takes_ownership(some_string: &mut String) {
    // some_stringはsへの可変参照
    some_string.push_str(", world!"); // some_string（sの値）を変更
}

不変および可変参照の使い分けとその意義

Rustでは、上記のように不変参照（&T）と可変参照（&mut T）が提供されています。不変参照はデータを読むために使用され、同時に複数の場所からの読み取りが可能ですが、データの変更は許可されていません。一方、可変参照はデータの変更を可能にしますが、安全性を確保するため、同時に存在できるのは一つだけです。この使い分けにより、Rustはデータ競合を防ぎ、メモリ安全性を保証します。

メモリ安全性を強化するRustの特徴

Rustのメモリ安全性は、単に所有権やライフタイムの概念だけに依存するわけではありません。Rustには、これらを補完し、メモリ安全性をさらに強化するいくつかの特徴があります。

コンパイル時のチェックとエラー処理の重要性

Rustの強力なコンパイラは、コードを実行する前に厳格なチェックを行い、メモリ安全でない操作や不適切なコードをエラーとして検出します。このコンパイル時チェックにより、実行時エラーや未定義の振る舞いが発生するリスクが大幅に減少します。Rustでは、このようなエラーチェックを通じて、より堅牢で信頼性の高いプログラムを作成することが可能です。

ResultとOption型を用いた堅牢なエラー処理の方法

Rustは、エラー処理のためにResultとOptionという2つの列挙型を提供します。Result型は成功した結果か、失敗を表すエラーのいずれかを含みます。これにより、関数が成功または失敗する可能性がある場合、その両方の状況を明示的に処理することが求められます。一方、Option型は値が存在するかどうかを表すために使用され、ヌル参照の問題を解決します。これらの型を使用することで、エラー処理がより明確かつ堅牢になります。

  • Result
    Result型は、成功した場合はOk値を、失敗した場合はErr値を返します。以下は、ファイルを読み込む関数の例です。ファイルの読み込みが成功すればOkで内容を返し、失敗すればErrでエラーを返します。
use std::fs::File;
use std::io::{self, Read};

fn read_file_contents(path: &str) -> Result<String, io::Error> {
    let mut file = File::open(path)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}
  • Option
    Option型は、何かの値が存在する場合はSomeを、存在しない場合はNoneを返します。以下は、ベクタから最初の要素を取得する関数の例です。要素があればSomeでその値を返し、なければNoneを返します。
fn first_element(v: Vec<i32>) -> Option<i32> {
    v.first().cloned()
}

fn main() {
    let numbers = vec![1, 2, 3];
    let no_numbers: Vec<i32> = vec![];

    println!("{:?}", first_element(numbers)); // Output: Some(1)
    println!("{:?}", first_element(no_numbers)); // Output: None
}

パニックとエラーの扱い方

Rustでは、回復不可能なエラーが発生した場合、プログラムは「パニック」状態になります。このメカニズムにより、プログラムの安全性が脅かされる可能性のある致命的な問題が発生したときには、即座に処理を停止し、リソースをクリーンアップすることができます。パニックは、エラーハンドリングの戦略の一部として使用され、プログラムが予期せぬ状況で安全に停止することを保証します。

Rustでは回復可能なエラーと回復不可能なエラーがあります。回復可能なエラーは上記のResult型を用いて扱います。Result型はOk値（成功した結果）またはErr値（エラー情報）を含みます。以下はResult型を使用したエラー処理の例

use std::fs::File;

fn open_file() -> Result<File, std::io::Error> {
    let f = File::open("hello.txt");

    match f {
        Ok(file) => Ok(file),
        Err(e) => Err(e),
    }
}

fn main() {
    match open_file() {
        Ok(file) => println!("ファイルが正常に開かれました。"),
        Err(e) => println!("ファイルのオープン中にエラーが発生しました: {:?}", e),
    }
}

回復不可能なエラーはパニックを扱う時で、プログラムはパニックを起こすと、実行を停止し、エラーメッセージを出力します。以下はパニックを起こす簡単な例です。

fn main() {
    panic!("予期しないエラーが発生しました！");
}

Rustのメモリ安全性がもたらす利点

Rustにおけるメモリ安全性は単にテクニカルな特徴以上のものを提供します。これには実用的な利点が多く、プログラムの品質と性能に直接的な影響を与えます。

バグの予防とプログラムの安全性の向上

Rustの所有権システムと借用チェッカーは、メモリ安全性違反やデータ競合などの一般的なバグを防ぎます。これにより、開発者はより安全なコードを書くことが可能になり、セキュリティリスクを減らすことができます。また、コンパイル時の厳格なチェックにより、実行時のエラーの可能性が減少し、より信頼性の高いプログラムを開発することができます。

Rustのメモリ管理がプログラムの性能に与える影響

Rustのメモリ管理は、プログラムの性能にも好影響を与えます。自動メモリ管理（ガベージコレクション）に頼らずに、メモリを効率的に使用することで、プログラムの実行速度と応答性が向上します。これは、特にリソースが限られている環境や、高性能を要求されるアプリケーションで顕著です。

他のプログラミング言語との比較

Rustを他のプログラミング言語と比較すると、そのメモリ安全性のアプローチのユニークさが際立ちます。例えば、CやC++ではメモリ管理はプログラマーの責任に大きく依存しており、これが複雑さとバグの原因になりがちです。一方で、JavaやPythonのような言語は自動メモリ管理を採用していますが、これにはパフォーマンスのトレードオフがあります。Rustは、これらの両方のアプローチのバランスをとり、安全性と効率性を両立させています。

結論

Rustは、その革新的なメモリ安全性の概念を通じて、プログラミングの新しい地平を開いています。所有権、借用、ライフタイムといった概念は、プログラマーがより安全で効率的なコードを書くのを助けます。また、コンパイル時のチェック、エラー処理の仕組み、そしてパニックハンドリングは、プログラムの堅牢性と信頼性を高めるのに大きく貢献しています。

以上です。ありがとうございました。

参考文献

https://doc.rust-jp.rs/book-ja/ch04-00-understanding-ownership.html

Discussion