Zenn
Open7

Rust のスマートポインタ Box を完全に理解したい

Rust
nukopynukopy

いつも何気なく書いている Result 型を返す関数で Box を使っている。

一番単純な例だと以下の通り。Result 型の型パラメータ Result<T, E> には std::error::Error トレイトを実装する型を Box で包んだ Box<dyn std::error::Error> 型を渡している。

rust
fn some_func() -> Result<(), Box<dyn std::error::Error>> {
    Ok(())
}

Box を取るとコンパイルエラーになる。

rust
-fn some_func() -> Result<(), Box<dyn std::error::Error>> {
+fn some_func() -> Result<(), dyn std::error::Error> {
    Ok(())
}

コンパイルエラー

error[E0277]: the size for values of type `(dyn std::error::Error + 'static)` cannot be known at compilation time
   --> head/src/box_practice.rs:1:19
    |
1   | fn some_func() -> Result<(), dyn std::error::Error> {
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `Sized` is not implemented for `(dyn std::error::Error + 'static)`
note: required by an implicit `Sized` bound in `Result`
   --> /Users/nukopy/.rustup/toolchains/stable-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/result.rs:527:20
    |
527 | pub enum Result<T, E> {
    |                    ^ required by the implicit `Sized` requirement on this type parameter in `Result`

error[E0277]: the size for values of type `dyn std::error::Error` cannot be known at compilation time
   --> head/src/box_practice.rs:2:5
    |
2   |     Ok(())
    |     ^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `Sized` is not implemented for `dyn std::error::Error`
note: required by a bound in `Ok`
   --> /Users/nukopy/.rustup/toolchains/stable-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/result.rs:527:20
    |
527 | pub enum Result<T, E> {
    |                    ^ required by this bound in `Ok`
...
531 |     Ok(#[stable(feature = "rust1", since = "1.0.0")] T),
    |     -- required by a bound in this tuple variant

For more information about this error, try `rustc --explain E0277`.
error: could not compile `head` (lib) due to 2 previous errors
nukopynukopy

Rust の Result と Box<dyn Error> の説明

なぜ Box<dyn std::error::Error> を使うのか

Box を使うことで、サイズが不定なトレイトオブジェクトをヒープに格納し、固定サイズのポインタを返すことができる。

  1. トレイトオブジェクト: dyn std::error::Error は、Error トレイトを実装する任意の型を表すトレイトオブジェクトです。これにより、異なる種類のエラーを同じ型として扱える。
  2. サイズの問題: トレイトオブジェクトは、コンパイル時にサイズが不明。Rust では、コンパイル時のルールとして関数の戻り値の型は具体的なサイズを持つ必要がある。
  3. Box の役割: Box はヒープ上にデータを格納するスマートポインタ。Box<dyn std::error::Error> とすることで、サイズが不明なトレイトオブジェクトをヒープに格納し、そのポインタ（固定サイズ）を返すことができる。
    • Box を使うとスタック上に、ヒープへ格納するデータへのポインタを置く。ポインタは固定サイズであるためコンパイル時にサイズが定まる。

なぜ Box を外すとコンパイルエラーになるのか

fn some_func() -> Result<(), dyn std::error::Error> {
    Ok(())
}

このコードがコンパイルエラーになる理由：

  1. Sized トレイト: Rust の型システムでは、デフォルトですべての型が Sized トレイトを実装していることを期待する。これは、その型のサイズがコンパイル時に要求されていることを意味する。
  2. dyn Error は Sized ではない: トレイトオブジェクト dyn std::error::Error は、具体的な型ではないため、サイズが不明でコンパイル時にサイズが定まらない。
  3. Result の制約: Result<T, E> の定義では、T と E の両方が Sized であることを暗黙的に要求している。
  4. スタック割り当て: 関数の戻り値は通常スタックに割り当てられますが、サイズが不明な型はスタックに直接割り当てられない。
nukopynukopy

Rust の Box ポインタの説明

Box ポインタの基本

Box が使用するポインタは、実際には「非ヌル化された生ポインタ」（non-nullable raw pointer）。Rust の内部実装では、これは *mut T 型として表現されるが、いくつかの重要な特性がある：

  1. 非ヌル: Box ポインタは常に有効なメモリ位置を指しているため、ヌルになることはない。
  2. 所有権: Box はデータの所有権を持つ。これは Rust の借用チェッカーによって強制される。
  3. サイズ: ポインタ自体のサイズは、プラットフォームのワードサイズ（32 ビットまたは 64 ビット）と同じ。

技術的な詳細

Box の内部実装は以下のようになっている（簡略化している）：

pub struct Box<T: ?Sized>(Unique<T>);

pub struct Unique<T: ?Sized> {
    pointer: *const T,
    _marker: PhantomData<T>,
}

ここで：

  • Box 型は、型パラメータ T: ?Sized を持つ、ジェネリックなタプル構造体。タプルの要素は Unique<T> 1 つのみ。
  • Unique<T> は型パラメータ T: ?Sized を持つジェネリックな構造体。非ヌル・非共有の生ポインタのラッパーである。
    • *const T は実際のポインタ値
    • PhantomData<T> は、型システムに T 型の値を「所有」していることを伝えるためのマーカートレイト

使用例

let x: Box<i32> = Box::new(5);
let y: Box<dyn std::error::Error> = Box::new(std::io::Error::new(std::io::ErrorKind::Other, "oh no!"));

println!("Size of Box<i32>: {} bytes", std::mem::size_of::<Box<i32>>());
println!("Size of Box<dyn Error>: {} bytes", std::mem::size_of::<Box<dyn std::error::Error>>());

このコードを実行すると、64ビットシステムでは変数 x, y 両方とも 8 バイト（64ビット）のサイズになる。これは、Box が内部的に単なるポインタであることを示している。

重要なポイント

  1. Box 型の値はポインタであり、スタック上では固定サイズの値として扱われる
  2. 実際のデータはヒープ上にあり、Box はそのデータへのポインタである
  3. Box は、コンパイル時にサイズがわからない型（例：トレイトオブジェクト）を扱う際に、サイズがわからない型をヒープに格納し、Box 自身はポインタとしてコンパイル時にサイズが定まりスタックに格納できるようになるため、特に有用
  4. Box ポインタは、Rust の安全性と所有権モデルに従って設計されている
nukopynukopy

T: ?Sized の意味

通常、Rust の型パラメータは暗黙的に Sized トレイトを要求する。つまり、コンパイル時に既知の固定サイズを持つ型のみを受け入れる。

?Sized は「サイズ不定」を意味する。これにより、型パラメータ T は Sized トレイトを実装していなくても良くなる。

この制約緩和により、Box は動的サイズ型（例：トレイトオブジェクト dyn Trait）も扱えるようになる。

コード例

// Box の簡略化された実装
pub struct Box<T: ?Sized>(Unique<T>);

// Unique の簡略化された実装（実際の実装はもっと複雑）
struct Unique<T: ?Sized> {
    ptr: *const T,
    _marker: PhantomData<T>,
}

// 使用例
fn main() {
    // 固定サイズの型の使用
    let boxed_int: Box<i32> = Box::new(42);
    
    // 動的サイズの型（トレイトオブジェクト）の使用
    let boxed_trait: Box<dyn std::fmt::Display> = Box::new(42i32) as Box<dyn std::fmt::Display>;
    
    println!("Boxed int: {}", boxed_int);
    println!("Boxed trait object: {}", boxed_trait);
}

ポイント

この実装の重要なポイントとしては、

  1. Box が実質的にはポインタのラッパーであること
  2. ?Sized により、Box が固定サイズの型だけでなく、動的サイズの型も扱えること
  3. この設計により、Box が Rust のメモリ安全性と所有権モデルを維持しながら、柔軟な使用を可能にしていること

Box<T: ?Sized> の定義は、Rust の型システムの強力さと柔軟性を示す良い例。

この設計により、Box は固定サイズの型（例：i32）と動的サイズの型（例：dyn Trait）の両方を効率的に扱うことができる。

これは特に、エラーハンドリングや多態性を扱う際に非常に有用。例えば、Box<dyn std::error::Error> のように、異なる具体的なエラー型を単一の型として扱うことができる。

nukopynukopy

「ポインタはメモリアドレスである」という主張は正しいか？：Rust の Box は「スマート」ポインタ

A. 「ポインタはメモリアドレスである」という説明は基本的に正しいが、Rust のコンテキストでは、多くの場合、それ以上の意味を持つことを理解することが重要。

Rustでは、ポインタは単なるメモリアドレス以上の情報を持つことがある。

Rustのポインタ詳細説明

基本的なポインタ

  • 最も基本的なレベルでは、ポインタはメモリアドレス
  • 例：*const Tや*mut T（生ポインタ）は、単純にメモリアドレスを表す

Rustの安全なポインタ

Rust には、単なるメモリアドレス以上の情報を持つ「安全な」ポインタ型がある：

  1. &Tと&mut T（不変参照、可変参照）
    • メモリアドレスに加えて、借用の情報（ライフタイム）を持つ
    • コンパイラがこの情報を使って、安全性を保証します。
  2. Box<T>
    • メモリアドレスに加えて、所有権の情報を持つ
    • ヒープ上のメモリの割り当てと解放を自動的に管理する
  3. Rc<T>やArc<T>
    • メモリアドレスに加えて、参照カウントの情報を持つ
  4. Unique<T>（Boxの内部実装）
    • メモリアドレスに加えて、非共有所有権の情報を持つ

ポインタと型情報

  • Rust のポインタは、多くの場合、指し示すデータの型情報も保持する
  • これにより、型安全性が保証され、適切なメモリレイアウトやアラインメントが維持される

実装の詳細

実際の実装では、これらの追加情報は以下のように扱われる：

  • 多くの場合、追加情報はコンパイル時に処理され、実行時のオーバーヘッドはない
  • 一部の情報（例：Rc の参照カウント）は実行時に管理される

したがって、「ポインタはメモリアドレスである」という説明は基本的に正しいが、Rust のコンテキストでは、多くの場合、それ以上の意味を持つことを理解することが重要。

まとめ

  1. 基本的には、ポインタはメモリアドレスを表すという主張は正確
  2. しかし、Rustのような高度な言語では、ポインタは単なるメモリアドレス以上の意味を持つことがある：
    • 所有権情報
    • ライフタイム情報
    • 型情報
    • 参照カウントなど

Rustのポインタを理解する際は、単純なメモリアドレスという概念から始め、そこに Rust 特有の安全性と所有権の概念を重ねていくと良い。これにより、低レベルのメモリ操作と高レベルの安全性保証を両立させる Rust の設計哲学がよく理解できる。（？）

nukopynukopy

C 言語のポインタとの比較

C 言語のポインタは単純にメモリアドレスを表すものだが、Rust のポインタはより洗練されている。Rust のポインタシステムの主な利点は以下の通り：

  1. 安全性：Rust のポインタは、null ポインタや dangling ポインタ（解放済みメモリを指すポインタ）を防ぐ
  2. 所有権とライフタイム：Rust のポインタは、データの所有権とライフタイムを追跡する。これにより、メモリリークや use-after-free（解放済みメモリへアクセスしようとする）などの問題を防ぐ
  3. 並行性の安全性：Rust のポインタシステムは、データ競合を防ぐのに役立つ
  4. 抽象化：Box、Rc、Arc などの異なる種類のポインタは、異なるユースケースに対応する

C言語 vs Rust のポインタ比較

C 言語と Rust のポインタの違いをより詳しく見てみる：

C言語のポインタ

int *ptr = malloc(sizeof(int));
*ptr = 42;
// 使用後に手動で解放する必要がある
free(ptr);

特徴：

  • 単純なメモリアドレス
  • 手動のメモリ管理
  • 型安全性が低い（キャストが容易）
  • null ポインタや dangling ポインタの可能性

Rust のポインタ（Box の例）

let boxed_int: Box<i32> = Box::new(42);
// スコープを抜けるときに自動的にメモリが解放される

特徴：

  • メモリアドレス + 追加の安全性情報
  • 自動メモリ管理
  • 強い型安全性
  • null や dangling ポインタがない
  • 所有権とライフタイムの概念

主な違い

  1. メモリ管理：
    • C：手動（malloc/free）
    • Rust：自動（RAII）
  2. 安全性：
    • C：プログラマの責任
    • Rust：コンパイラが保証
  3. 抽象化：
    • C：低レベルの直接的なメモリ操作
    • Rust：高レベルの抽象化（Box, Rc, Arc など）
  4. 並行性：
    • C：スレッド安全性はプログラマの責任
    • Rust：型システムによってデータ競合を防止

Rust のポインタシステムは、C 言語のような低レベル制御を維持しつつ、高レベルの安全性と抽象化を提供する。これにより、メモリ関連のバグを大幅に減少させることができる。

この比較から、Rust のポインタシステムが C 言語のそれと比べてより安全で抽象化されていることがわかる。Rust は低レベルのシステムプログラミングの能力を維持しつつ、高レベルの言語のような安全性を提供している。

Rust を学ぶ上で重要なのは、これらの安全性メカニズムを理解し、活用することです。特に所有権、借用、ライフタイムの概念は、Rust の核心部分であり、これらを理解することで、メモリ安全性を損なうことなく効率的なコードを書くことができます。
C 言語の経験がある方にとって、Rust の学習曲線は少し急かもしれませんが、一度マスターすれば、安全で高性能なシステムを構築する強力なツールとなります。

だそうです

nukopynukopy

結局 Box ってなに？

Box は、Rust においてデータをヒープメモリに格納するためのスマートポインタ。以下の特徴を持つ。

  • ヒープ割り当て（heap allocation）：データを自動的にヒープメモリに配置する
  • 所有権：ヒープに格納されたデータの唯一の所有者となる
  • サイズ不定対応：コンパイル時にサイズがわからない型も扱える（ヒープ割り当てなので、プログラム実行中に動的にメモリが割り当てられるため、コンパイル時にサイズが決まっている必要がなく、コードに型の柔軟性をもたせることができる。Boxed な型は、コンパイル時のサイズ要求はヒープへのポインタが満たしてくれる。これにより、中身の型のサイズはコンパイル時に要求されなくなる。）
  • 自動クリーンアップ：スコープを抜けると自動的にメモリを解放する（これは Box の特徴というよりは Rust の RAII の上で Box が実装されていることによる）