クロージャ（Closure）とは

Rust におけるクロージャ（Closure）とは、「その場で定義できる無名の関数のようなもの」のことです。

通常の fn で定義する関数との大きな違いは、外部のスコープにある変数を利用できることです。この「外側の変数を取り込んで使う」ことを「キャプチャ（capture）」と呼びます。

共通的な変数をクロージャの中に取り込んでおくことで、他の可変な値と組み合わせながら、柔軟で再利用可能な処理を定義することができます。

この記事では、Rust におけるクロージャの基本的な使い方や考え方について紹介します。

クロージャの基本

クロージャの基本的な使い方

基本的なクロージャの使い方を紹介します。

|引数1, 引数2, ...| 式

クロージャの構文は非常にシンプルです。上記のように || 内に引数を列挙し、クロージャの返却値となる式をその後に記載します。引数なしのクロージャー (|| 式) でも問題ありません。

また、複数の文を書く場合は、以下のように {} のブロックを使用します。

|引数1, 引数2, ...| {
    文;
    ...;
    式
}

最後の式は、クロージャの戻り値になります。最後に ; (セミコロン) をつけると戻り値は () となります。

それでは、簡単な具体例で確認してみましょう。

単一式の例

fn main() {
    // ===== 単一の式のクロージャ例
    let add = |a, b| a + b;
    println!("add(2, 3) = {}", add(2, 3));
}

【実行結果】
add(2, 3) = 5

この例では、変数 a と b を受け取り a + b という単一の式を計算するクロージャを定義して add という変数名に束縛しています。a + b がクロージャの戻り値になります。

クロージャを使用する時には「add(2, 3)」のように使用します。もちろん、add(4, 5)、 …のように任意の引数での再利用が可能です。

単一の式の場合であれば、{} を使用しなくても上記のように簡潔に書くことができます。

引数なしの例

fn main() {
    // ===== 引数なしのクロージャ例
    let greet = || "Hello, Rust!";
    println!("greet() = {}", greet());
}

【実行結果】
greet() = Hello, Rust!

クロージャは、引数がなくても使用できます。引数がない場合、|| のように何も書かずに定義します。この例では、"Hello, Rust!" という文字列リテラルがそのまま戻り値になります。

ブロック形式の例

fn main() {
    // ===== ブロック形式のクロージャ例
    let multiply = |a, b| {
        println!("calculating {a} * {b} ...");
        // 最後の式がクロージャの戻り値になる
        a * b
    };
    println!("multiply(3, 5) = {}", multiply(3, 5));
}

【実行結果】
calculating 3 * 5 ...
multiply(3, 5) = 15

複数の文を実行したい場合には、{} ブロックを使用します。例では、計算前に println! でメッセージを表示し、その後に a * b を評価しています。

Rust では、ブロックの最後の式が戻り値になるというルールがあります。そのため、a * b に ; (セミコロン) をつけないことが重要です。; を付けた場合の返却値は () となります。

外側の変数をキャプチャする例

ここまでの例は、関数とほぼ同じような使い方でした。しかし、クロージャの本質は「外側の変数を利用できること」です。以下の例で、外側の変数をキャプチャする例を見てみましょう。

fn main() {
    // ===== 外側の変数をキャプチャするクロージャ例
    let base = 10;

    let add_to_base = |x| base + x;
    println!("add_to_base(5) = {}", add_to_base(5));
}

【実行結果】
add_to_base(5) = 15

この例では、base という変数をクロージャの外側で定義しています。add_to_base は、引数 x だけを受け取っていますが、計算で base も利用しています。このように add_to_base を用意しておくと、様々な x に対して base を足した結果を再利用して計算できます。

あたかも add_to_base が base 変数を捕捉した状態で使いまわせるため「キャプチャする」という表現が使われています。

このように、外側のスコープにある変数を取り込んで使用することができるのがクロージャの本質です。ここまでの例を振り返るとクロージャーは次のような特徴があることが分かります。

• 関数のように振る舞う
• fn を使わなくても、その場で定義することができる
• 外側の変数を利用することができる（キャプチャできる）

つまり、単なる無名関数というだけではなく、定義された環境設定ごと関数を扱える仕組みであることがクロージャの本当の価値です。

クロージャの型注釈と型推論

引数の型注釈

クロージャーは型推論がされるため、基本的には型注釈を入れる必要はありません。以下のように型注釈を入れたクロージャも使うことができます。

fn main() {
    // ===== 単一の式のクロージャ例 (型注釈あり)
    let subtract = |a: i32, b: i32| a - b;
    println!("subtract(5, 2) = {}", subtract(5, 2));
}

【実行結果】
subtract(5, 2) = 3

例のように a: i32, b: i32 といった形で型注釈を書くことができます。なお、戻り値については、let subtract = |a: i32, b: i32| -> i32 { a - b }; のように書くことも可能ですが、引数の型が決まれば、戻り値の型は式から自動推論できるため、通常は記載しません。

クロージャの型推論

クロージャは型推論をすると記載しましたが、どこで型が確定するかというと「最初にクロージャが使用されたときの型」で確定となります。そのため、先ほどの例で一度 add(2, 3) と使用した後に以下のように、floating-point で使用しようとするとコンパイルエラーとなります。

println!("add(1.0, 2.0) = {}", add(1.0, 2.0));

【エラー例】
error[E0308]: arguments to this function are incorrect
  --> rust-basic\closure-basic\examples\closure_basic.rs:28:36
   |
28 |     println!("add(1.0, 2.0) = {}", add(1.0, 2.0));
   |                                    ^^^ ---  --- expected integer, found floating-point number
   |                                        |
   |                                        expected integer, found floating-point number

クロージャのキャプチャの方法

ここでは、クロージャのキャプチャについて少し詳しく見てみましょう。キャプチャとは、クロージャが外側のスコープにある変数を取り込んで利用することでした。

Rust のクロージャでは、外側の変数をどのように扱うかに応じて、キャプチャ方法をコンパイラが自動で選択します。主なキャプチャの方法には以下の 3 種類です。

1. 不変参照でのキャプチャ
2. 可変参照でのキャプチャ
3. move による所有権の移動でのキャプチャ

不変参照でのキャプチャ

外側の変数を「読み取るだけ」であればクロージャは、変数を不変参照でキャプチャします。この場合、外側の変数は所有権を失わないため、クロージャ呼び出し後も引き続き利用できます。

fn main() {
    // ===== 不変参照でのキャプチャ例
    let x = 10;
    // x は不変参照でキャプチャされる
    let f = |y| x + y;

    // クロージャの呼び出し
    println!("f(5) = {}", f(5));
    // xはまだ使用可能
    println!("x = {}", x);
}

【実行結果】
f(5) = 15
x = 10

例のクロージャでは、x を不変参照しているだけで変更していません。そのため、クロージャを呼び出した後でも x は使用できます。

可変参照でのキャプチャ

クロージャの中で外側の変数を変更する場合、クロージャはその変数を可変参照でキャプチャします。以下は、count 変数をクロージャ内部でカウントアップしているような例です。

fn main() {
    // ===== 可変参照でのキャプチャ例
    let mut count = 0;
    println!("count before: {}", count);
    // countは可変参照でキャプチャされる
    let mut g = || count += 1;

    // クロージャを呼び出すとcountが変更される
    g();
    // countは変更されている
    println!("count after: {}", count);
}

【実行結果】
count before: 0
count after: 1

可変参照でキャプチャする場合は、外側の変数は let mut により、変更可能（ミュータブル）な変数として定義する必要があります。また、クロージャを変数（上記例では g）に束縛する場合は、g についても let mut で変更可能な形で定義する必要があります。

move による所有権の移動でのキャプチャ

これまでの例では、外側の変数は参照としてキャプチャされていました。以下のようにクロージャの定義の前に move をつけることで、外側の変数は所有権ごとクロージャに移動します。

fn main() {
    // ===== move による所有権の移動でのキャプチャ例
    let s = String::from("Hello");
    // s は move で所有権がクロージャに移動される
    let h = move || println!("{s} World!");

    // 実行時に s は消費されて使用できなくなる
    h();
    // sはmoveで所有権が移動されているため以降は使用できない
    // println!("{s}"); // コンパイルエラー
}

【実行結果】
Hello World!

【move 後のコメントアウト部分を外した場合のコンパイルエラー 一部抜粋】
error[E0382]: borrow of moved value: `s`
  --> rust-basic\closure-basic\examples\closure_capture.rs:31:16
   |
24 |     let s = String::from("Hello");
   |         - move occurs because `s` has type `String`, which does not implement the `Copy` trait
25 |     // s は move で所有権がクロージャに移動される
26 |     let h = move || println!("{s} World!");
   |             -------            - variable moved due to use in closure
   |             |
   |             value moved into closure here
...
31 |     println!("{s}"); // コンパイルエラー
   |                ^ value borrowed here after move

例のように、move を付けた時点で変数 s の所有権はクロージャに移動します。そのため、以降外側のスコープでは s は使用できません。使用しようとするとコンパイルエラーとなります。（例でコメントアウトしている部分を外して試してみてください。）

move は、外側の値の所有権をクロージャ側に移して、クロージャがその値を保持できるようにしたい場合に使います。（例：スレッドに渡す、関数の外へ変数を持ち出す など）

クロージャの型とトレイト

クロージャの基本的な使い方を紹介してきました。記事の冒頭で、クロージャは「その場で定義できる無名の関数のようなもの」という少し曖昧な表現をしました。これは、クロージャの型やトレイトをより理解すると、関数とは異なるということが分かるためです。

少し詳細な内容になるため、クロージャの型とトレイトについては「クロージャの型とトレイト（Fn / FnMut / FnOnce）」でまとめていますので参考にしてください。

まとめ

Rust におけるクロージャ（Closure）の基本を解説しました。

クロージャは 「 |引数1, 引数2, …| 式」の形式で、その場で定義できる無名の関数のような仕組みです。ブロック形式の場合は、最後の式が戻り値になります。また、型注釈は必要に応じて記載できますが、多くの場合は型推論に任せることができます。

さらに、クロージャの本質である「キャプチャ」について、不変参照・可変参照・move による所有権移動の 3 パターンを紹介しました。特に move を使うと、外側の値の所有権がクロージャに移動し、以降は外側のスコープでは利用できなくなる点が重要です。

クロージャは、その場で処理を定義できる非常に便利な機能で、Rust ではさまざまな場面で利用されます。まずは、基本的な書き方とキャプチャの考え方をしっかり押さえておきましょう。

あわせて読みたい

Rust プログラミング入門

Rust の文字列

どのプログラミング言語においても文字列を適切に扱えるようになることは非常に重要です。Rust では、文字列を扱う際に主に登場するのが「String 型」と「文字列スライス &str 型」の2つです。

String 型は Rust の標準ライブラリとして提供される可変長の文字列型です。String 型は、文字列リテラル（例："Hello"）とは異なり、ヒープ領域に格納されて動的にメモリが確保されます。

文字列スライス（&str） は、UTF-8 エンコードされた文字列データへの参照（借用）です。データ本体は別の場所（静的領域やヒープ領域）に存在し、&str はその一部または全体を参照する仕組みです。

この記事では、Rust の String 型と文字列スライス &str 型について分かりやすく解説します。

String 型

String 型とは

Rust における String 型は、可変長でありかつ所有権を持つ文字列型です。String は、ヒープ領域に格納され、実行時にサイズを変更したり、編集したりすることが可能です。ユーザーからの入力やファイルから読み込むデータ等、動的に得られる文字列を保持したいときには String を使用します。

String 型の使い方

String::from() を使用する

String を生成する一般的な方法は、標準ライブラリの String 型の関連関数 String::from() を用いて生成する方法です。ヒープ上に新たに String の文字列が確保されます。

fn main() {
    // 関連関数 from を使って生成
    let s = String::from("HelloWorld");

    println!("{}", s);
}

【実行結果】
HelloWorld

to_string() メソッドを使用する

文字列スライスに対して to_string() メソッドを呼び出すことで、String に変換することも可能です。

fn main() {
    // to_string メソッドを使って生成
    let s = "HelloWorld".to_string();

    println!("{}", s);
}

【実行結果】
HelloWorld

format マクロを使用する

format マクロを使うことで String 文字列を生成できます。

fn main() {
    // format マクロを使って生成
    let part = "World";
    let s = format!("Hello{}", part);

    println!("{}", s);
}

【実行結果】
HelloWorld

print マクロが、コンソールに文字列を出力するのに対して、format マクロは String オブジェクトを返します。変数の値を埋め込んで文字列を生成したい場合に便利です。

関連関数 String::new() を使用する

関連関数である String::new 関数を使うことでも生成ができます。

fn main() {
    // 関連関数 new を使って生成
    let mut s = String::new();
    // 文字列を追加
    s.push_str("HelloWorld");

    println!("{}", s);
}

【実行結果】
HelloWorld

変数宣言時点では、文字列が決まっておらず後で決まるような場合には、あらかじめ new で用意しておいて、 push_str メソッドなどで文字列を追加して使用します。String 型の各種メソッドについては後ほど詳しく説明します。

String::from() と to_string() の違い

String::from() と to_string() メソッドはどちらも同じ動作をするため、どちらの方法を利用しても構いません。内部的には、String::from() は、String 型の関連関数として定義されており、一方で to_string() メソッドは、ToString トレイトの実装に依存しています。

例えば、上記例の "HelloWorld" は、文字列スライス &'static str 型です。文字列スライスについては後ほど説明しますが、&str 型は ToString トレイトを実装しているため String 型に変換できます。

どちらを利用するかは好みやスタイルの違いで選んでも基本的には問題ありませんが、to_string() は ToString トレイトの実装に依存しており場合によっては期待しない型変換が行われない可能性もあります。明示的な意図を示す場合や型安全性を重視する場面では String::from() を使用するとより安全です。

String 変数の変更（文字列の追加・結合・削除）

String 型の変数はヒープ領域に格納されているので文字列の追加や削除といったことが可能です。文字列の変更では、以下のようなメソッドを使用できます。

文字列の追加

文字列の追加では、push、push_str、insert、insert_str メソッドを使用できます。

• push：末尾に 1 文字追加します。
• push_str：末尾に文字列を追加します。
• insert：指定バイト位置に 1 文字追加します。
• insert_str：指定バイト位置に文字列を追加します。

fn main() {
    // push(char) で1文字末尾に追加
    let mut s1 = String::from("HelloWorld");
    s1.push('!');
    println!("{}", s1);

    // push_str(&str) で文字列スライスを末尾に追加
    let mut s2 = String::from("Hello");
    s2.push_str("World!");
    println!("{}", s2);

    // insert(index, char) で指定バイト位置に1文字を追加
    let mut s3 = String::from("HeloWorld!");
    s3.insert(3, 'l');
    println!("{}", s3);

    // insert_str(index, &str) で指定バイト位置に文字列スライスを追加
    let mut s4 = String::from("Helrld!");
    s4.insert_str(3, "loW");
    println!("{}", s3);
}

【実行結果】
HelloWorld!
HelloWorld!
HelloWorld!
HelloWorld!

文字列の結合

文字列の結合では、+ 演算子か format マクロを使用できます。

fn main() {
    // +演算子で文字列を結合する
    let s1 = String::from("Hello");
    let s2 = String::from("World");
    
    // s1 の所有権はムーブするので注意、s2 は参照を渡す必要がある
    let s3 = s1 + &s2;
    println!("{}", s3);

    // s1 の所有権は移動するので以下はコンパイルエラー
    // println!("{}", s1);

    // format マクロで結合する（ムーブなしで結合可能）
    let s1 = String::from("Hello");
    let s2 = String::from("World");

    // format で結合
    let s3 = format!("{}{}", s1, s2);
    println!("{}", s3);
    // ムーブしないので元の変数も使用できる。
    println!("{}", s1);
    println!("{}", s2);
}

【実行結果】
HelloWorld
HelloWorld
Hello
World

+ 演算子の場合、左辺の変数の所有権はムーブするため、以降では使えなくなるので注意が必要です。また、右辺の変数は参照を渡す必要があります。

一方、format マクロで結合する場合には、元の変数の所有権を保持したまま String を生成するため、結合後も元の変数を使用することができます。また、format マクロは内部的には参照として処理されるため、変数はそのまま渡すことができます。

文字列の削除

文字列の削除では、pop、remove、truncate、clear メソッドを使用できます。

• pop：末尾から1文字を削除し、Option<char> で削除した文字列を返します。
• remove：指定したバイト位置の 1 文字を削除し、char 型を返します。
• truncate：指定したバイト位置以降を削除します。返却値はありません。
• clear：文字列の全てを削除します。

各方法で、返却値の有無や型が異なっているので注意してください。

fn main() {
    let mut s = String::from("HelloWorld");
    
    // pop() で末尾の文字を取得
    match s.pop() {
        Some(c) => println!("pop: {}", c),
        None => println!("文字列が空なので取り出せません"),
    }
    println!("s: {}", s);

    // remove(index) で指定バイト位置の1文字を削除
    let c = s.remove(1);
    println!("remove idx:{}, removed:{}", 1, c);
    println!("s: {}", s);

    // truncate で指定バイト位置以降を削除
    s.truncate(4);
    println!("s: {}", s);

    // 文字列を全て削除する
    s.clear();
    println!("s: {}", s);
}

【実行結果】
pop: d
s: HelloWorl
remove idx:1, removed:e
s: HlloWorl
s: Hllo
s:

返却値の有無や型が異なっているので取り出し方がそれぞれ異なっています。なお、remove や truncate は、Option 型のような安全な型を返すメソッドではないため、範囲外インデックスを指定すると実行時に panic を引き起こし、プログラムが異常終了します。

insert、remove、truncate はバイト位置であることに注意

insert、remove、truncate といったメソッドは、位置の指定がバイト位置となっています。そのため、マルチバイト文字を含む場合で、マルチバイト文字の途中のバイト位置を指定すると panic で実行時にエラーとなるので注意が必要です。

マルチバイト文字を含む場合は、以下のように char_indices() メソッドを使ってバイト位置を検索してから安全に処理することが推奨されます。

fn main() {
    // バイト位置を指定する場合は、マルチバイト文字の時に注意
    // ===== insert の場合
    let mut s1 = String::from("Rust、こんにちは。");

    // 以下は panic となる
    // s1.insert(5, '!');

    // 文字数でバイト位置を検索してからであれば安全
    if let Some((idx, _)) = s1.char_indices().nth(10) {
        s1.insert(idx, '!');
    }
    println!("{}", s1);

    // ===== remove の場合
    let mut s2 = String::from("Rust、こんにちは。");

    // 以下は panic となる
    // s1.remove(5);

    // 文字数でバイト位置を検索してからであれば安全
    if let Some((idx, _)) = s2.char_indices().nth(4) {
        s2.remove(idx);
    }
    println!("{}", s2);

    // ===== truncate の場合
    let mut s3 = String::from("Rust、こんにちは。");

    // 以下は panic となる
    // s3.truncate(5);

    // 文字数でバイト位置を検索してからであれば安全
    if let Some((idx, _)) = s3.char_indices().nth(4) {
        s3.truncate(idx);
    }
    println!("{}", s3);
}

【実行結果】
Rust、こんにちは!。
Rustこんにちは。
Rust

上記例でコメントアウトしたの部分を外すと panic で実行時にエラーとなります。例の文字列で 5 バイト目は「、」の途中のバイトを指すためです。

char_indices().nth(x) で x 文字目のバイト位置を調べることができます。このメソッドは、Option型で位置と文字のタプルを取得でき、match や if let を使えば安全に処理できます。

String 型の内部構造

String 型の変数は、ヒープ領域に確保されることが特徴ですが、後ほど説明する文字列スライスとの違いを明確に理解するために、内部構造を理解しましょう。String 型の変数は、スタック上に以下の内容を含む情報を格納しています。

• ヒープアドレス上の先頭アドレス（8バイト）
• ヒープ上で使用中のバイト数（8バイト）
• ヒープ上で確保済のバイト数（8バイト）

このように String 型は 8 バイト × 3 の 24 バイト で構成される変数としてスタックのメモリ領域を使用します。概要イメージとしては以下のようになっており、実際の文字列はヒープ領域に格納されます。

具体的に以下のコードで内部情報を確認してみます。

use std::mem;

fn main() {
    let s1 = String::from("HelloWorld");
    let s2 = String::from("Rust こんにちは！");

    println!("===========================================");
    println!("s1 の文字列の内容: {}", s1);
    println!("s1 のスタック上のアドレス: {:p}", &s1);
    println!("ポインタ: {:p}", s1.as_ptr());
    println!("長さ: {}", s1.len());
    println!("容量: {}", s1.capacity());
    println!("String のサイズ（byte）: {}", mem::size_of_val(&s1));
    println!("===========================================");
    println!("s2 の文字列の内容: {}", s2);
    println!("s2 のスタック上のアドレス: {:p}", &s2);
    println!("ポインタ: {:p}", s2.as_ptr());
    println!("長さ: {}", s2.len());
    println!("容量: {}", s2.capacity());
    println!("String のサイズ（byte）: {}", mem::size_of_val(&s2));
    println!("===========================================");
}

【実行結果】
===========================================
s1 の文字列の内容: HelloWorld
s1 のスタック上のアドレス: 0xddb70ff510
ポインタ: 0x2655f95eff0
長さ: 10
容量: 10
String のサイズ（byte）: 24
===========================================
s2 の文字列の内容: Rust こんにちは！
s2 のスタック上のアドレス: 0xddb70ff528
ポインタ: 0x2655f95f2f0
長さ: 23
容量: 23
String のサイズ（byte）: 24
===========================================

上記例では、s1 と s2 という String 型の変数を用意し、内部の情報を調べています。

まず、変数のスタック上のアドレス（&s1 と &s2）は、println! で {:p} とすることで確認できます。また、std::mem::size_of_val(&s1) により具体的なメモリ上の大きさを調べられます。 これにより、String 型の変数がスタック上で 24 バイトのメモリを確保していることを確認できます。

String 型を構成する、ヒープ領域の先頭アドレス値は as_ptr() メソッド、長さは len() メソッド、容量は capacity() メソッドで確認することができます。上記例では、長さと容量が一致していますが、コンパイラが長さに対して余裕をもって確保することが多いです。

文字列スライス（&str 型）

文字列スライス（&str 型）とは

Rust において、文字列スライス（&str）は、UTF-8 でエンコードされた文字列の一部または全体を参照するための型です。これは、借用（参照）型であり、データの所有権を持ちません。データの本体は静的領域やヒープ領域に存在し、&str はそこへのポインタと長さを持つだけの軽量な構造を持っています

プログラム上の文字列リテラル（例："HelloWorld"）は、プログラムの静的領域に格納されており、型は &'static str 型です。ここで、'static は静的なライフタイムを表しており、プログラムの開始から終了までのライフタイムを持つ型であることを示しています。

また、String 型の変数は、&str 型に暗黙的に変換することができるため、関数等で &str 型を引数として受け取る設計にすることで、文字列リテラルでも String 型でも扱う関数とすることができます。

文字列スライス（&str 型）の使い方

&str 型は、以下のような状況でよく使用されます。

• 文字列リテラルとして使用する
• 文字列リテラルや String からの部分文字列として使用する
• 関数の引数として、汎用的に文字列を受け入れる

文字列リテラルとして使用

最も単純な使い方は、文字列リテラルとして使用する方法です。

fn main() {
    let s = "HelloWorld";
    println!("s: {}", s);
}

【実行結果】
s: HelloWorld

文字列リテラルや String の部分文字列として使用する

文字列スライスは、スライスという名の通り、文字列リテラルや String の部分文字列への参照を取得することができます。文字列リテラルや String の s があった時に &s[開始..終了] のように部分文字列の範囲を指定します。

開始と終了はバイト位置で、終了位置の文字は含まないことに注意してください。また、開始を省略して [..終了] すると開始から終了位置までの文字列を、終了を省略して [開始..] とすると開始位置から終了までの文字列を取得できます。なお、[..] は文字列全体を表します。

fn main() {
    let s1 = "HelloWorld";
    let s2 = String::from("HelloWorld");

    let s1_part = &s1[2..5];
    let s2_part = &s2[5..];
    println!("s1_part: {}", s1_part);
    println!("s2_part: {}", s2_part);
}

【実行結果】
s1_part: llo
s2_part: World

文字列スライスもバイト位置を指すことから、 String の注意事項と同様に、マルチバイト文字の途中のバイト位置を指定すると panic が発生します。事前に char_indices() を使用してバイト位置を確認してから処理すると安全です。

関数の引数として、汎用的に文字列を受け入れる

関数の引数として文字列を受け取る場合にも、&str 型をよく使用します。String 型の参照は、自動で &str へ変換されるため、以下の例では String の参照である &s2 についても show_str 関数は受け取ることができます。

fn show_str(s: &str) {
    println!("{}", s);
}

fn main() {
    let s1 = "HelloWorld";
    let s2 = String::from("HelloWorld");

    show_str(&s1);
    show_str(&s2);
}

【実行結果】
HelloWorld
HelloWorld

文字列スライス &str 型の内部構造

&str 型の変数は、静的領域に格納される文字列リテラル、またはヒープ領域に格納される String を指しています。内部構造としては、&str 型の変数は、スタック上に以下の内容を含む情報を格納しています。

• 文字列が格納されている先頭アドレス（8バイト）
• スライスのバイト数（8バイト）

このように &str 型は 8 バイト × 2 の 16 バイト で構成される変数としてスタックのメモリ領域を使用します。概要イメージとしては以下のようになっており、文字列の実体は、文字列リテラルの場合は静的領域に、String の場合はヒープ領域に格納されます。

具体的に以下のコードで内部情報を確認してみます。

use std::mem;

fn main() {
    let s1 = "HelloWorld";
    let s2 = String::from("Rust こんにちは！");
    let s2_slice = &s2[..];

    println!("===========================================");
    println!("s1 の文字列の内容: {}", s1);
    println!("s1 のスタック上のアドレス: {:p}", &s1);
    println!("ポインタ: {:p}", s1.as_ptr());
    println!("長さ: {}", s1.len());
    println!("&str のサイズ（byte）: {}", mem::size_of_val(&s1));
    println!("===========================================");
    println!("s2_slice の文字列の内容: {}", s2_slice);
    println!("s2_slice のスタック上のアドレス: {:p}", &s2_slice);
    println!("ポインタ: {:p}", s2_slice.as_ptr());
    println!("長さ: {}", s2_slice.len());
    println!("&str のサイズ（byte）: {}", mem::size_of_val(&s2_slice));
    println!("===========================================");
}

【実行結果】
===========================================
s1 の文字列の内容: HelloWorld
s1 のスタック上のアドレス: 0x80d46ff2c8
ポインタ: 0x7ff61530b4f0
長さ: 10
&str のサイズ（byte）: 16
===========================================
s2_slice の文字列の内容: Rust こんにちは！
s2_slice のスタック上のアドレス: 0x80d46ff2f0
ポインタ: 0x26c1d91f010
長さ: 23
&str のサイズ（byte）: 16
===========================================

上記例では、文字列リテラルである s1 と String s2の参照としての s2_slice の &str 型で内部情報を取得して表示しています。

上記例の s1.as_ptr() は静的領域を、s2_slice.as_ptr() はヒープ領域を指すアドレスとなっています。また、std::mem::size_of_val() により取得できるバイト数が 16 であることから、&str 型のスタック上でのメモリサイズが 16 バイトであることが確認できます。

まとめ

Rust で文字列を扱うための String と &str の基本的な使い方と内部的な構造の違いについても詳しく説明しました。

動的な操作には String を、参照だけで十分な場合は &str を使うなど、用途に応じた選択ができるようになることが重要です。また、各種メソッドなどについても紹介しましたが、マルチバイト文字を含む場合のバイト位置指定の扱いには十分に注意し、char_indices() を活用した安全な操作を心がけましょう。

文字列操作は、どのようなプログラミング言語においても非常に重要な要素です。String と &str について、基本をしっかり押さえてプログラミングできるようになりましょう。

あわせて読みたい

Rust プログラミング入門

Rust の構造体（struct）

構造体（struct）とは

Rust では、複数の値を1つにまとめて扱う構造体（struct）が重要な要素です。これは、オブジェクト指向言語におけるクラスのような役割をします。

ただし、Rust にはクラス構文は存在しません。Rust は「安全性と柔軟性の両立」を重視したプログラミング言語であり、継承を使わずに構造体（struct）と実装（impl）、トレイト（trait）を組み合わせることでクラスのような柔軟な振る舞いを実現しています。

この記事では、Rust の構造体の基本的な使い方から便利な初期化方法、メソッド定義、所有権の考え方まで初心者にも分かりやすく解説します。

構造体の定義方法とインスタンス化

構造体の定義方法

Rust の構造体は、自分で定義する「型」の一種です。複数の異なるデータ型の値を1つにまとめることができるデータ型として扱うことができます。

例えば、人物の情報を表現する場合には以下のように Person 構造体を定義できます。

[person.rs]

// Person構造体を定義
#[derive(Debug)]
struct Person {
    first_name: String,
    last_name: String,
    sex: String,
    age: u32,
    birthday: String,
}

fn main() {
    // Personをインスタンスを作成する
    let person = Person {
        first_name: String::from("太郎"),
        last_name: String::from("山田"),
        sex: String::from("男性"),
        age: 25,
        birthday: String::from("2000-01-01"),
    };

    // 各要素にアクセスする
    println!(
        "{}{}さん({})は、{}歳で誕生日は{}です。",
        person.last_name, person.first_name, person.sex, person.age, person.birthday
    );
    // Debugフォーマットで表示する
    println!("{:?}", person);
}

【実行結果】
山田太郎さん(男性)は、25歳で誕生日は2000-01-01です。
Person { first_name: "太郎", last_name: "山田", sex: "男性", age: 25, birthday: "2000-01-01" }

構造体は struct キーワードを使って構造体名を定義します。Rust では構造体名には UpperCamelCase という各単語の頭文字を大文字にして単語をつなげる形式が慣習です。

構造体が持つ各要素（first_name など）のことをフィールドと言いますが、フィールドは「フィールド名: 型」という形で定義します。構造体のインスタンスを作成する際には、let person のところで定義しているように「フィールド名: 値」という形で列挙します。

構造体の各要素にアクセスしたい場合には、person.first_name のように「インスタンス名.フィールド名」でアクセスすることが可能です。

また、構造体の定義では [derive(Debug)] という記載をつけることで、Debug フォーマットでの表示ができます。println! マクロにおいて {:?} とすると、この部分に定義した構造体の各情報を自動でフォーマットして表示してくれます。[derive(Debug)] は、Debug トレイトを自動実装してくれる便利な機能ですので覚えておいてください。

構造体は全体が「mutable」または「immutable」

Rust では、変数は基本的に不変（immutable）です。これは、Rust の安全性を高める仕組みで値を変更する変数は、プログラマが明示的に mut キーワードで明示する必要があります。

Rust の構造体では、構造体全体が「可変（mutable）」か「不変（immutable）」かを指定します。フィールド単位ではなく、構造体単位で可変性が決まる点に注意しましょう。

[mutable_immutable.rs]

// Person 構造体の定義は同じなので省略

fn main() {
    // 可変 (mutable) で変数を定義
    let mut person1 = Person {
        first_name: String::from("太郎"),
        last_name: String::from("山田"),
        sex: String::from("男性"),
        age: 24,
        birthday: String::from("2000-01-01"),
    };
    // 値の変更はOK
    person1.age += 1;
    println!(
        "{} {} {} {} {}",
        person1.last_name, person1.first_name, person1.sex, person1.age, person1.birthday
    );

    // 不変 (immutable) で変数を定義
    let person2 = Person {
        first_name: String::from("花子"),
        last_name: String::from("山田"),
        sex: String::from("女性"),
        age: 20,
        birthday: String::from("2005-01-01"),
    };
    println!(
        "{} {} {} {} {}",
        person2.last_name, person2.first_name, person2.sex, person2.age, person2.birthday
    );

    // 値の変更はできない (コンパイルエラー)
    // person2.age += 1;
}

【実行結果】
山田 太郎 男性 25 2000-01-01
山田 花子 女性 20 2005-01-01

上記の例で、person2 は immutable なので、person2.age += 1; の行のコメントアウトを外すとコンパイルエラーとなります。

Rust では、このように構造体全体で可変性を統一することで一貫性を保証しています。

様々な初期化方法

構造体を定義し、インスタンスを初期化する際には便利な初期化方法があるので紹介します。

フィールドと変数が同名のとき（フィールド初期化省略記法）

関数 create_person に変数を渡して構造体をインスタンス化し、返却する場合を考えてみます。この時、通常は以下のように記載します。

[field_init.rs]

fn create_person(
    first_name: String,
    last_name: String,
    sex: String,
    age: u32,
    birthday: String,
) -> Person {
    // Person インスタンスを生成して返却する
    Person {
        first_name: first_name,
        last_name: last_name,
        sex: sex,
        age: age,
        birthday: birthday,
    }
}

この例では「first_name: first_name」のように毎回同じ記載をするのが面倒です。このようにフィールド名と変数名が同じ場合のために Rust では「フィールド初期化省略記法」というものが用意されており「フィールド名: 変数名」の部分を以下のように省略できます。

[field_init_shorthand.rs]

fn create_person(
    first_name: String,
    last_name: String,
    sex: String,
    age: u32,
    birthday: String,
) -> Person {
    // フィールド初期化省略記法
    Person {
        first_name,
        last_name,
        sex,
        age,
        birthday,
    }
}

他のインスタンスからインスタンスを生成（構造体更新記法）

同様のフィールド値がある場合に毎回構造体の定義を書くのは大変です。そのような際に、既存の構造体インスタンスをもとに、新しいインスタンスを作成する構造体更新記法があります。構造体更新記法では「..」を使用して以下のように定義できます。

[update_syntax.rs]

fn main() {
    let person1 = Person {
        first_name: String::from("太郎"),
        last_name: String::from("山田"),
        sex: String::from("男性"),
        age: 25,
        birthday: String::from("2000-01-01"),
    };

    // 構造体更新記法で新しいインスタンスを生成する
    let person2 = Person {
        first_name: String::from("花子"),
        sex: String::from("女性"),
        ..person1
    };

    println!(
        "{}{}さん({})は、{}歳で誕生日は{}です。", 
        person2.last_name, person2.first_name, person2.sex, person2.age, person2.birthday
    );
}

【実行結果】
山田花子さん(女性)は、25歳で誕生日は2000-01-01です。

構造体更新記法で注意が必要なこと

構造体更新記法を紹介しましたが、この方法は注意すべき点があります。それは、省略したフィールドのうち Copy トレイトが実装されていない型の場合は、所有権の移動が起こってしまうということです。上記で person2 を作成した後、以下のコードを書いてみてください。

[update_syntax_move.rs]

    // 一部フィールドでも所有権の移動が起こると構造体本体を使用できない。
    // ただし、個々のフィールドについては Copy トレイトの実装有無で挙動が異なる
    //  - Copy トレイトが実装されている場合: フィールドの値がコピーされるので使用できる
    //  - Copy トレイトが実装されていない場合: フィールドの所有権が移動するので使用不可

    // 以下のコメントアウトを外すとコンパイルエラー
    // println!("{:?}", person1);
    println!("{}", person1.first_name);
    // println!("{}", person1.last_name);
    println!("{}", person1.sex);
    println!("{}", person1.age);
    // println!("{}", person1.birthday);

person1 のフィールドのうち、last_name と birthday はアクセスできなくなっており、コンパイルエラーとなります。これは、構造体更新記法により所有権が移動しているためです。また、一部でもフィールドの所有権移動が起こると構造体本体の person1 へはアクセスできなくなります。

一方で、age は u32 型の基本型で Copy トレイトが実装されているため person2 のフィールドにコピーされるため、person1.age のように個別に指定すれば引き続きアクセスが可能です。

このように String や Vec のように所有権が移動する型をフィールドに含むような構造体の場合には構造体更新記法の使用は注意が必要です。例えば、以下の Rectangle 型の例のように基本型のみを含むような構造体の場合は、全てコピーになるので安心して使用できます。

[update_syntax_save.rs]

// 矩形構造体 Rectangle
struct Rectangle {
    width: u32,
    height: u32,
    color_code: u8,
}

fn main() {
    let rect1 = Rectangle {
        width: 100,
        height: 50,
        color_code: 1,
    };

    // 構造体更新記法で新しいインスタンスを生成する
    // 基本型ばかりなのでコピーになる
    let rect2 = Rectangle {
        color_code: 2,
        ..rect1
    };

    // rect1 のフィールドにもアクセスできる
    println!("矩形1 widhth:{}, height:{}, color_code:{}", rect1.width, rect1.height, rect1.color_code);
    println!("矩形2 widhth:{}, height:{}, color_code:{}", rect2.width, rect2.height, rect2.color_code);
}

【実行結果】
矩形1 widhth:100, height:50, color_code:1
矩形2 widhth:100, height:50, color_code:2

タプル構造体（名前付きでフィールドのない構造体）

タプル構造体とは、フィールド名を持たない構造体で、シンプルなデータ構造の定義に適しています。各フィールドの意味が明確で、名前を付ける必要がない、もしくは名前付けすることで冗長になってしまうようなケースでよく使用されます。

よく例で紹介される Color や Point を使って見てみましょう。

[tuple_struct.rs]

// Color タプル構造体
struct Color(u8, u8, u8);
// Point タプル構造体
struct Point(i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0);

    println!("黒 = ({}, {}, {})", black.0, black.1, black.2);
    println!("原点 = ({}, {})", origin.0, origin.1);
}

【実行結果】
黒 = (0, 0, 0)
原点 = (0, 0)

このように Color や Point は、RGB や X軸, Y軸 のように順序と意味が慣例で明確なのでタプル構造体で定義することに適しています。なお、通常の構造体定義では {} であったのが、タプル構造体では () になっているので注意しましょう。

構造体のメソッド

Rust では、構造体に関連付けられた関数を「メソッド（method）」と呼びます。これは impl ブロックの中で定義され、self を引数に取ることが特徴です。

[method.rs]

// Person 構造体の定義は同じなので省略

impl Person {
    // あいさつをするメソッド
    fn greet(&self) {
        println!(
            "こんにちは。{}{}と言います。{}歳の{}で、誕生日は{}です。",
            self.last_name, self.first_name, self.age, self.sex, self.birthday,
        );
    }

    // 氏名を返却するメソッド
    fn full_name(&self) -> String {
        format!("{}{}", self.last_name, self.first_name)
    }

    // 年齢を比較するメソッド (self以外の引数をとる場合)
    fn is_older_than(&self, other_age: u32) -> bool {
        self.age > other_age
    }

    // 誕生日で年齢を+1するメソッド (可変参照とする場合)
    fn have_birthday(&mut self) {
        self.age += 1;
    }

    // 新しいPersonインスタンスを生成する (関連関数という)
    fn new(first_name: &str, last_name: &str, sex: &str, age: u32, birthday: &str) -> Person {
        Person {
            first_name: first_name.to_string(),
            last_name: last_name.to_string(),
            sex: sex.to_string(),
            age,
            birthday: birthday.to_string(),
        }
    }
}

fn main() {
    // 関連関数を使って Person のインスタンスを作成
    let mut person = Person::new("太郎", "山田", "男性", 25, "2000-01-01");

    // greet メソッドの呼び出し
    person.greet();

    // full_name メソッドの呼び出し
    let full_name = person.full_name();
    println!("フルネーム: {}", full_name);

    // is_older_than メソッドの呼び出し
    let other_age = 30;
    if person.is_older_than(other_age) {
        println!("{}歳より年上です。", other_age);
    } else {
        println!("{}歳より年下です。", other_age);
    }

    // 誕生日を迎えたので have_birthday を呼び出し
    person.have_birthday();
    println!("誕生日を迎えて、{}歳になりました。", person.age);
}

【実行結果】
こんにちは。山田太郎と言います。25歳の男性で、誕生日は2000-01-01です。
フルネーム: 山田太郎
30歳より年下です。
誕生日を迎えて、26歳になりました。

メソッドでは、第1引数に self という自身を指す変数を取る必要があります。値を参照するのみの場合は、不変参照（&self）を引数に取れば十分ですが、構造体のフィールドを書き換えるような場合には、可変参照（&mut self）を受け取る必要があります。

また、通常の関数と同様に値の返却（full_name メソッド）や他の引数を受け取る（is_older_than メソッド）ということもできます。

なお、self を引数に取らない new のような関数を関連関数と言います。関連関数は、構造体のインスタンスを必要とせずに呼び出せる関数で、self を引数に取らないため static な性質を持ちます。主に new 関数のようなコンストラクタ的用途や、定数の返却、型変換などのユーティリティ関数に使われます。他のオブジェクト指向言語におけるクラスの static メソッドに相当します。

構造体の所有権

Rustでは、構造体全体が1つの所有権を持ち、変数間の代入によって所有権全体が移動します。

[ownership_borrowing.rs]

// Person 構造体の定義は同じなので省略

// メソッドの実装 (impl Person) は同じなので省略

fn main() {
    let person1 = Person::new("太郎", "山田", "男性", 25, "2000-01-01");

    // 所有権が移動する
    let person2 = person1;

    // 以下はコメントアウトを外すとコンパイルエラー
    // println!("person1: {}", person1.first_name);

    // 所有権を移動させない場合は、参照を使用する
    let person3 = &person2;
    println!("person2: {}", person2.first_name);
    println!("person3: {}", person3.first_name);
}

上記の例では「let person2 = person1;」の部分で所有権が移動するため、person1 はフィールド値にもうアクセスできません。

所有権を移動させない場合は、借用（不変参照 または 可変参照）を使用しますが、その時には構造体のフィールド全体が一貫して参照として扱われます。

ただし、個々のフィールドに対して移動や借用することも可能であり、その場合は、各フィールドで所有権の扱いと借用のルールが適用されます。上記の構造体更新記法で一部の String の所有権が移動したような例もその1つです。

まとめ

この記事では、Rust における構造体（struct）の基本的な使い方について解説しました。

構造体は、複数の値をまとめて扱うデータ型として、Rust でのデータ構造の設計において非常に重要な役割を果たします。フィールドの初期化、省略記法や構造体更新記法、タプル構造体、メソッドや関連関数の定義方法などを学ぶことで、より柔軟で表現力のあるプログラムが書けるようになります。

また、Rust の特徴である所有権と借用の仕組みも構造体に密接に関係しており、安全なメモリ管理を実現するために正しく理解しておくことが重要です。ぜひ、実際にコードを書いて試しながら、構造体の理解を深めてみてください。

あわせて読みたい

Rust プログラミング入門

Rust の所有権（Ownership）

所有権の規則

Rust の公式ドキュメントである The Book の所有権の章で書かれている基本原則は以下の3つです。

1. Rust の各値は、所有者と呼ばれる変数と対応している。
2. 所有権を持てる変数は、ある時点で必ず1つだけである。
3. 所有権がスコープから外れたら、値は破棄される。

Rust では、各値に対して「誰が責任をもつか（所有権をもつか）」を明確にします。実行のあらゆる瞬間において所有者となる変数は必ず1つであり、その変数がスコープから外れると、所有する値は自動的に破棄されます。これにより、メモリの手動解放が不要になり、メモリリークを防ぐことができます。

また、所有者の変数がスコープを抜けたときに1度だけ破棄処理が行われるため、C/C++ のように手動で開放する必要がありません。これにより、メモリの二重解放といったバグも防ぐことができます。

所有権の移動（ムーブ）

所有権を持っている変数は、所有者である間は自由に使うことができます。しかし、変数への代入などが行われる際に、所有権が移ります。所有権が移動することをムーブ（move）と言います。ただし、所有権を移動せずにコピーとして処理される例もありますので、そのパターンについては後述します。

所有権が移動される代表的なパターンは以下になります。

1. 他の変数への代入
2. 関数に引数として渡すとき
3. 関数から戻り値として返すとき

それぞれを簡単な例で見ていきましょう。

他の変数への代入

以下は、String 型の変数 s1 の値を s2 に代入している例です。

fn main() {
    let s1 = String::from("Hello World!");

    // 所有権が s1 から s2 に移動（ムーブ）する
    let s2 = s1;

    // ここから s1 は使用できなくなる
    println!("{}", s1);
}

上記の例でコンパイルをしようとすると「borrow of moved value: s1」というコンパイルエラーとなります。これは「let s2 = s1;」のタイミングで所有権が s2 へ移動してしまっているためです。

関数に引数として渡すとき

以下は、main 関数で定義した s1 という String 型の変数を関数 takes_ownership へ実引数として渡しています。

// 所有権が呼び出し元の変数から s に移動（ムーブ）してくる
fn takes_ownership(s: String) {
    println!("{}", s);
}

fn main() {
    let s1 = String::from("Hellow World");

    // 所有権が関数の引数に移動（ムーブ）する
    takes_ownership(s1);

    // ここから s1 は使用できなくなる。
    println!("{}", s1);
}

上記についてもコンパイルしようとすると「borrow of moved value: s1」というコンパイルエラーとなります。この例では、関数の仮引数 s に渡された際に所有権が s に移っています。そのため、main 関数では s1 は使用できなくなります。

また、println! の部分をコメントアウトすればコンパイルはできますが、関数側に所有権が渡されていることにより関数ブロックが終わったタイミングで s は既に破棄されます。そのため、関数から戻った時点で文字列は既に破棄されています。

関数から戻り値として返すとき

以下は、関数 gives_ownership 関数内で定義した s を呼び出し元の main 関数へ返している例です。

fn gives_ownership() -> String {
    let s = String::from("Hello World");
    // 所有権が呼び出し元に移動（ムーブ）する
    s
}

fn main() {
    // 関数で定義した変数の所有権が移動（ムーブ）してくる
    let s1 = gives_ownership();

    println!("{}", s1);
}

上記の例では、gives_ownership 関数内で定義された変数ですが、main 関数側に戻ってきた際に、s1 変数に所有権が移っています。

ムーブ と コピー

上記では、所有権の移動が起こる例を見てきました。Rust では、変数の代入や関数への引数渡しの際には「ムーブ」または「コピー」が行われます。

コピーでは、主にスタック上に保持されているような小さなデータ型の値が、ビット列ごと複製され、両方の変数が独立してメモリ上に同じ値を保持できます。一方でムーブでは、元の変数から新しい変数へ所有権だけが移り、実体はメモリ上に1つだけです。

Rust の型においては、以下のような違いがあります。

• 基本型の i32 などのスタックに格納される変数はコピーとなる。
• String、Vec<T> などのヒープに格納される変数はムーブとなる。

Rustでは、データがメモリ上のどこに置かれるか（スタック or ヒープ）によって、コピーされるかムーブされるかが決まる傾向があります。

ヒープで確保される型は、サイズを変更することができ、容量が大きくなる可能性もあることから、コピー自体の負荷も高くなる可能性があるためです。一方で、スタックに配置される型は、サイズも小さく決まっており、コピーは素早くできるため、全体の効率が良くなります。

スタックとヒープ

スタックとヒープという言葉を出しましたので、簡単に触れておきましょう。メモリ領域の中には「テキスト領域」「静的領域」「スタック領域」「ヒープ領域」という領域が分かれています。それぞれの領域の使われ方は以下の通りです。

• テキスト領域：プログラムの実行コードが格納されます。
• 静的領域：static 変数など、プログラム全体を通じて使われる値が格納されます。
• スタック領域：関数の変数（ i32、bool など）の小さな値が置かれます。サイズが決まっているため出し入れが速く処理効率が高いです。
• ヒープ領域：String や Vec<T> のようにサイズが実行時に決まるデータが使う領域です。

コピーとムーブの例を確認

コピーされる例とムーブされる例を見ておきましょう。

fn main() {
    // コピーされる例 (i32)
    let x = 10;
    let y = x;
    // コピーなので x も y も使用できる
    println!("{}", x);
    println!("{}", y);

    // 移動 (ムーブ) される例 (String)
    let s1 = String::from("Hello World");
    let s2 = s1;
    // 所有権が移っているので s2 は使える
    println!("{}", s2);
    // s1 は使えない (コメントアウトを外すとコンパイルエラー)
    // println!("{}", s1);
}

上記では、基本型である i32 の変数 x、y の代入と、String 型である s1、s2 の代入をしています。基本型である i32 は x の値が y にコピーされるためどちらの値も使用できています。一方で、String 型については、s2 = s1; の時点で所有権が移動（ムーブ）しているため、それ以降 s1 は使えません。（上記例でコメントアウトを外すとコンパイルエラーとなります。

clone の活用：所有権を保持したままデータをコピー

所有権が移動するような String、Vec 型についても clone() を使用することにより明示的にコピーすることも可能です。

fn main() {
    let s1 = String::from("Hello World!");

    // clone によりコピーをすることも可能
    let s2 = s1.clone();

    // s1 も s2 もいずれも使える
    println!("{}", s1);
    println!("{}", s2);
}

【実行結果】
Hello World!
Hello World!

Rust では、コンパイルエラーで非常に詳しくエラーメッセージを出してくれますので、メッセージを注意深く読むことで、問題の場所やスコープをしっかり見直すことで所有権の問題を解消することができます。

ただし、Rust 初心者でどうしてもコンパイルエラーを解消できない場合は、clone() を使用して所有権の問題を回避するのも1つの方法です。clone() を使用するような型（String や Vec）はヒープ領域にあるデータであるため、コピーで複製することは実行コストが基本型などよりも高くなる傾向にあります。このことを理解して使用をよく検討するようにしましょう。

Rust の借用（Borrowing）

借用（Borrowing）とは、所有権の移動を行わずに、他の変数から値を一時的に使わせてもらうことです。借用の中には、以下の2種類の参照があります。

• 不変参照（immutable reference）：読み取り専用の借用
• 可変参照（mutable reference）：書き込み可能な借用

それぞれの例を見ていきましょう。

不変参照

不変参照（immutable reference）は、読み取り専用の借用であり、「&」キーワードを使用して表します。

fn print_message(s: &str) {
    // 不変参照なので読み取りのみ
    println!("{}", s);
}

fn main() {
    let s1 = String::from("Hello World");

    // s1 の内容を不変参照で関数に渡す
    print_message(&s1);

    // s1 は所有権を持っているので、ここでもまだ使える
    println!("{}", s1);
}

【実行結果】
Hello World
Hello World

関数を呼び出す際には、「&変数名」という形で不変参照を渡します。関数側の型注釈も「: &型名」としておく必要があります。

上記例では、関数 print_message に不変参照で s1 変数を渡しています。この時には、所有権の移動（ムーブ）は起こらないため、関数から戻ってきた際でも s1 変数を使用することが可能です。なお、関数の終了と共に、関数内の参照変数 s のスコープは終了します。ただし、参照先の実体 s1 が破棄されるわけではありません。

可変参照

可変参照（mutable reference）は、書き込みも可能な借用であり、「&mut」キーワードを使用して表します。

fn append_message(s: &mut String) {
    // 可変参照なので変更可能
    s.push_str("!!!");
}

fn main() {
    let mut s1 = String::from("Hello World");

    // s1 の内容を可変参照で関数に渡す
    append_message(&mut s1);

    // 関数側で変更された結果が表示される
    println!("{}", s1);
}

関数を呼び出す際には、「&mut 変数名」という形で可変参照を渡します。関数側の型注釈も「: &mut 型名」としておく必要があります。

上記の例では、変更可能なように参照を渡しているため、関数 append_message 側で文字列を変更することが可能です。また、main 関数に戻ってきた際にも変更が反映されていることが確認できます。なお、関数の終了と共に、関数内の参照変数 s のスコープは終了します。ただし、参照先の実体 s1 が破棄されるわけではありません。

借用チェッカー（borrow checker）

Rust のコンパイラには、借用チェッカー（borrow checker）という重要な機能があります。この機能は、借用が安全に使われているかをコンパイル時に自動的にチェックしてくれます。Rust が「コンパイラが通れば安全性が保証される」と言われる中核の機能です。

所有者である元の変数と共に存在できる参照の組み合わせは、基本的に次の2つのどちらかに限られます。

1. 元の変数（所有者）＋ 1つまたは複数の不変参照
2. 元の変数（所有者）＋ 可変参照 1つ

借用の基本的な考え方としては、以下のようになっており、借用チェッカーがコンパイルでチェックしてくれます。

• 参照があるときには、元の所有権を持つ変数であっても値の変更はできません。
• 可変参照（&mut T）は、ある時点で1つだけしか存在できません。これによりデータの競合を防止することができます。
• 可変参照と不変参照は共存できません。これにより、不変参照が参照している間に意図せず値が変わってしまうことはありません。
• 参照が存在する間は、参照先のデータは解放されず、必ず有効なまま保持されます。これにより無効なメモリを指す状態（ダングリングポインタ）は発生しません。

現在状態に対して、どういった対応が可能かをまとめた表が以下になります。

まとめ

Rust の所有権と借用の仕組みは、最初は少し難しく感じるかもしれません。しかし、この記事で紹介したように、基本的なルールは非常に明確でシンプルです。

• 所有権を持つ変数は必ず1つだけです。
• 所有権は移動（ムーブ）が基本ですが、型の種類によりコピーの場合もあります。
• 借用により渡せる参照には不変参照と可変参照があり、それぞれ同時に扱える条件が異なります。
• Rust のコンパイラは「借用チェッカー」によって、これらのルールをコンパイル時に厳密にチェックしてくれます。

この仕組みにより、C/C++ などの言語でよく見られる メモリの二重解放やダングリングポインタといったバグを、言語レベルで防止できます。結果として、安全で効率的なプログラムを記述することができるのが Rust の大きな魅力です。

最初のうちは所有権や借用でコンパイルエラーになることも多いかもしれませんが、それは Rust が安全性を重視して設計された言語である証拠です。丁寧にエラーメッセージを読み、今回学んだルールを少しずつ理解していけば、自然と扱えるようになっていくと思います。

所有権と借用は、Rust の基礎であり、理解が進めば進むほど Rust らしいコードが書けるようになります。ぜひ繰り返し復習して、確かな理解を身につけてください。

あわせて読みたい

Rust プログラミング入門

Rust 関数の基本

プログラミングにおいて関数とは、何度も使用するようなコードを1つのブロックにまとめて関数として名前付けし、何度も使うようにできるものです。関数は、プログラミングにおいてどのような言語であっても中核的な役割をします。

この記事では、Rust における関数定義や引数などの基本について分かりやすく解説します。

基本的な関数定義と呼び出し

Rust の関数は、fn を使用して以下のように定義します。

fn 関数名() {
    // 関数で実行する処理
}

以下は、入力された整数の2乗を返す square 関数を定義し、main 関数から呼び出している例です。

// 2乗を返す関数 square を定義
fn square(x: i32) -> i32 {
    x * x
}

fn main() {
    // square関数を呼び出し
    let result = square(2);
    
    println!("2 の 2乗 は {} です。", result);
}

【実行結果】
2 の 2乗 は 4 です。

関数 square が受け取っている x を引数と言い、「: i32」の部分は引数の型を示す型注釈と言います。また、「-> i32」の部分は、戻り値の型を示す型注釈です。Rust では関数の最後の式が戻り値となるため、戻り値として値を返す際には「x * x」のようにセミコロン（;）をつけずに記載します。引数や戻り値については以降で詳しく説明します。

作成した関数を呼び出すときには、main 関数内で let result = square(2); としているように「関数名();」で何度でも呼び出すことができます。また、戻り値を let を使って変数に束縛することも可能です。

関数定義のルール

関数定義のルールについて、整理しておきましょう。

型注釈は必須

関数では、引数の型注釈（例：x: i32）や戻り値の型注釈（例：-> i32）を明示することが必須です。変数定義の時は、型推論により型が推論されますが、関数の引数の場合は異なるので注意しましょう。ただし、戻り値がないような関数の場合は「->」の型注釈は省略可能です。

戻り値にはセミコロン「;」を付けない

Rust では、関数の最後の式が戻り値となります。セミコロン「;」を記載すると文となってしまうため、関数内で戻り値を書く場合には「;」を付けないように注意してください。

fn square(x: i32) -> i32 {
    x * x    // セミコロンを付けない
}

関数名はスネークケース（snake_case）が慣習

関数名は、小文字をアンダースコアでつなげるスネークケース（snake_case）で書くのがRustの慣習となっています。

戻り値と早期終了 (return)

Rust では、関数の最後の式が戻り値になることを見てきましたが、return キーワードを使って明示的に値を返すことも可能です。

以下の例では、絶対値を返却する abs 関数を作成し、x < 0 の場合は、その場で -x を return により返して早期終了しています。

fn abs(x: i32) -> i32 {
    if x < 0 {
        // 早期終了 (return)
        return -x;
    }
    // 通常の戻り値
    x
}

fn main() {
    // abs関数を呼び出し
    let result1 = abs(-5);
    let result2 = abs(10);

    println!("結果 result1: {}, result2: {}", result1, result2);

}

【実行結果】
結果 result1: 5, result2: 10

関数の最後で return を使うのは、非常に多くの言語で見られる方法です。もちろん、Rust でも最後の戻り値で return を使うことができますが、Rust では、最後の戻り値では return を書かないことが一般的です。

関数のシャドーイング（定義の上書き）

Rust では、変数の定義で同じ変数名で let における再定義をすることができました。関数でも同じようにシャドーイングにより定義を上書きすることができます。

関数の場合には、外側のスコープで定義した関数を、内側のスコープでシャドーイングすることで定義を上書きすることができます。let の時には同一スコープで再定義ができましたが、関数は同一スコープでは複数回の定義はできないので注意してください。

以下の例で見てみましょう。

fn message() {
    println!("メッセージ 1");
}

fn show_message() {
    message();  // 「メッセージ 1」を表示
}

fn main() {
    message();  // 「メッセージ 2」を表示
    {
        message();  // 「メッセージ 3」を表示

        fn message() {
            println!("メッセージ 3");
        }
    }
    message();  // 「メッセージ 2」を表示
    show_message(); // show_message関数経由で「メッセージ 1」を表示

    fn message() {
        println!("メッセージ 2");
    }
}

【実行結果】
メッセージ 2
メッセージ 3
メッセージ 2
メッセージ 1

上記の例だと、message という名前の関数を3回定義しています。show_message 関数が使用するのは「メッセージ 1」と表示する message 関数です。一方で、main 関数の最初のスコープでは「メッセージ 2」と表示する message 関数を、一段階内側の {} ブロック内での呼び出しでは「メッセージ 3」と表示する message 関数を呼び出します。

このように、関数もスコープによってシャドーイングされる対象となります。ただし、このようにスコープ内で入れ子に関数を定義していくようなスタイルは可読性がよくありません。上記の例は、関数もシャドーイングされるという Rust の言語仕様を説明するものだと理解してください。

関数の引数と戻り値の扱い

ここからは、関数の引数と戻り値の扱いについて、もう少し詳しく見ていきましょう。

引数を値で渡す

関数では、引数として値を渡すことができます。引数では、関数定義で使用される引数を「仮引数（parameter）」、呼び出し時に渡される引数を「実引数（argument）」と言います。

仮引数は渡された実引数に対する別名ではなく、オブジェクトのコピーとなっています※。つまり、メモリー上では別で格納されているものです。このコピーは、関数を呼び出すときに作られて、関数が終わって制御が呼び出し元に戻るときに破棄されます。

// x は仮引数
fn square(x: i32) -> i32 {
    x * x
}

fn main() {
    let x = 2;

    // x は実引数
    let result = square(x);
    
    println!("{} の 2乗 は {} です。", x, result);
}

上記の例では、square 関数の x: i32 が仮引数で、main 関数内の x が実引数です。main 関数内で square 関数が呼び出されると square 関数の x としてコピーが作成され、square 関数処理がされて値を返した際に破棄されています。

その後の println! で x を使用していますが、この値は main 関数で最初に定義している let x = 2; です。これは、C言語にもある値渡しの仕組みと同じものです。

関数から値を返す

関数では、引数を受け取るだけではなく、処理結果を呼び出し元に返すことができます。上記の例でも見てきたように関数の戻り値は、最後の式の値になります。

fn square(x: i32) -> i32 {
    x * x  // 戻り値となる式
}

関数の戻り値を表す型注釈は、関数名の後の「->」に続けて記載をします。例えば、戻り値がないような関数の場合は、空のタプル () が戻されているとみなされます。戻り値がない場合には「-> ()」は省略可能です。

複数の値を返す

関数から複数の値を返却したい場合には、タプルを使用することで値を返すことができます。以下は、入力された2つの引数で min と max を計算し、(min, max) のタプルとして返却している例です。

// 最小(min), 最大(max) を確認し、(min, max) のタプルで返却する
fn min_max(a: i32, b: i32) -> (i32, i32) {
    if a < b {
        (a, b)
    } else {
        (b, a)
    }
}

fn main() {
    let a = 10;
    let b = 5;

    let (min, max) = min_max(a, b);
    println!("min: {}, max: {}", min, max);
}

【実行結果】
min: 5, max: 10

呼び出し側の変数の扱い（不変参照と可変参照）

これまでの例では、実引数を関数の仮引数にコピーして処理を返して値を返すというような例を見てきました。実際には、呼び出し元の変数を直接変更したい場合も出てきます。このような場合について、Rustでは所有権という考え方を意識しないといけません。ここでは、基本型と所有権を持つ型（String や Vec）に分けて説明をします。

基本型の場合

基本型はメモリのスタック領域に置かれる型で通常や仮引数へ渡す際にはコピーされます。呼び出し元の基本型の値を変更したい場合には、以下のように &mut として値を変更できる可変参照を渡して使用します。

// 呼び出し元の変数を変更する
fn increment(n: &mut i32) {
    *n += 1;
}

fn main() {
    let mut num = 0;

    // 1回目の呼び出し (可変参照)
    increment(&mut num);
    println!("num: {}", num);
    // 2回目の呼び出し (可変参照)
    increment(&mut num);
    println!("num: {}", num);
}

【実行結果】
num: 1
num: 2

変更が可能な参照を指定する場合には、呼び出し時に実引数には「&mut 変数」のように渡します。一方で、受け取る関数の型注釈は「: &mut 型名」を付けます。Rust において & は参照を表します。そして、* は参照から値を取り出すための演算子です。今回は可変参照を使用しているので、値を書き換えることができます。

&mut num は、変数 num の可変な参照を渡しているので、関数 increment で *n により値を変更しています。main 関数で呼び出しから戻ってきた際に num の値が変更されていることからも分かると思います。

所有権を持つ型の場合

基本型について見ましたが、所有権を持つ型（String や Vec）といった型では基本型と少し挙動が異なり、所有権の移動や借用（不変参照、可変参照）について意識する必要があります。

所有権が移動する場合

String 型の例で説明をしていきます。まずは、所有権が移動してしまう例を見てみましょう。

// 所有権が移動 (move) する場合
fn print_str_move(s: String) {
    println!("print_str_move: {}", s);
}

fn main() {
    // 所有権の移動の確認
    let s1 = String::from("Hello World");
    print_str_move(s1);
    println!("呼び出し元のs1: {}", s1);
}

【実行結果】
error[E0382]: borrow of moved value: `s1`
  --> examples\arg_param_string_move.rs:10:30
   |
8  |     let s1 = String::from("Hello World");
   |         -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait
9  |     print_str_move(s1);
   |                    -- value moved here
10 |     println!("呼び出し元のs1: {}", s1);
   |                                    ^^ value borrowed here after move
   |
note: consider changing this parameter type in function `print_str_move` to borrow instead if owning the value isn't necessary
  --> examples\arg_param_string_move.rs:2:22
   |
2  | fn print_str_move(s: String) {
   |    --------------    ^^^^^^ this parameter takes ownership of the value
   |    |
   |    in this function
   = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider cloning the value if the performance cost is acceptable
   |
9  |     print_str_move(s1.clone());
   |                      ++++++++

For more information about this error, try `rustc --explain E0382`.
error: could not compile `function_basic` (example "arg_param_string_move") due to 1 previous error

この例では、コンパイル時にエラーとなります。これは、関数に s1 を渡す際に所有権を関数側へ移動（move）しているためです。この時に、"Hello World" が格納されるオブジェクトは関数へ所有権が移り、関数呼び出し後に解放されてしまいます。そのため、呼び出し元で再度呼び出そうとするとエラーとなってしまいます。

これを回避する1つの方法は、help に記載のように clone() を使用してコピーを渡すことです。以下のようにするとエラーは起こりません。

// コピーを受け取っている
fn print_str_move(s: String) {
    println!("print_str_move: {}", s);
}

fn main() {
    // 所有権の移動の確認
    let s1 = String::from("Hello World");
    
    // 所有権が移動しないようにコピーを渡す
    print_str_move(s1.clone());
    println!("呼び出し元のs1: {}", s1);
}

ただし、String や Vec のようにヒープ領域を使用する型はサイズが可変であることから、使用している領域が大きい可能性があり、コピーをすることは不必要なメモリ利用や応答性の低下につながる可能性があります。そのため、以降で紹介する借用（不変参照や可変参照）をうまく使用します。

借用（不変参照と可変参照）

所有権を借用するケースについて見ていきましょう。Rust において借用には、読み取り専用の「不変参照」と変更も可能な「可変参照」があります。これらは呼び出し元で定義している変数が指すオブジェクトへの参照です。

// 不変参照 (読み取り専用) の場合
fn print_str_ref(s: &String) {
    println!("print_str_ref: {}", s);
}

// 可変参照 (変更可) の場合
fn print_str_change(s: &mut String) {
    s.push_str("!!!");
    println!("print_str_change: {}", s);
}

fn main() {
    // 不変参照の場合
    let mut s1 = String::from("World World");
    print_str_ref(&s1);

    // 可変参照の場合
    print_str_change(&mut s1);
    println!("呼び出し元のs1: {}", s1);
}

【実行結果】
print_str_ref: World World
print_str_change: World World!!!
呼び出し元のs1: World World!!!

読み取り専用の不変参照で関数を定義する場合には、型注釈として「: &型名」として定義します。関数呼び出しの際には「&変数名」で渡します。これは、呼び出し元のオブジェクトを指していますが、読み取り専用の参照のため誤った値の変更を避けることができます。

次に変更可の可変参照で関数を定義する場合には、型注釈として「: &mut 型名」として定義します。関数呼び出しの際には「&mut 変数名」で渡します。これは変更可であるため呼び出し元の変数の値を変更します。そのため、上記例で main 関数に戻ってきた際に s1 の値が変わっていることが分かります。

上記の内容は所有権の考え方をまだ学んでいない方には少し難しいかもしれません。所有権や借用については、別途詳しく説明しようと思います。

まとめ

Rust の関数は、明確な型注釈や所有権のルールにも従って、安全で予測可能なコードを書くために必要なものです。この記事では、関数の基本的な定義方法から、引数と戻り値の扱い、所有権と参照の使い分けまでを学びました。

特に、以下のポイントを押さえておきましょう。

• 関数の引数と戻り値には型注釈が必須（ただし、戻り値がない場合は省略可能）
• 関数の最後の式が戻り値（セミコロンをつけない）
• 所有権の移動と参照（不変・可変）の違いを理解する
• 基本型と所有権を持つ型（Stringなど）で挙動が異なる

Rustの関数をしっかりと理解することは、より発展的なジェネリクスやクロージャなどの理解のために必要です。ぜひこの記事を参考に、関数の書き方に慣れていきましょう。

あわせて読みたい

Rust プログラミング入門

Rust とは何か？

Rust は、非常に高いパフォーマンスやメモリ安全性など、近年人気が高まってきているモダンなプログラミング言語の 1 つです。

なぜ Rust に注目が集まっているのか？

Rust は、なぜ近年注目を集めているのでしょうか。いくつかの理由をご紹介します。

信頼性・安全性の高い実装の実現

近年は、サイバーセキュリティの脅威が増加しており、攻撃者はシステムの脆弱性をついて攻撃してきます。そのため、信頼性の高いシステムを構築することが必要不可欠です。Rust では、メモリ安全性を言語レベルで保証するような仕組みがあり、コンパイルが通れば、メモリ安全性の多くが保証されるため、非常に信頼性の高いシステムを構築できます。

実際に、バッファオーバーフローやダングリングポインタ（解放されたメモリ領域を指すポインタ）へのアクセスなどメモリ安全性の問題は、重大な脆弱性の大半を占めるとも言われています。このように、セキュリティ要求への対応への高まりに伴い、Rust への注目と期待が高まっています。

高速性と開発効率の両立

これまでは、高性能な処理を実現するには C/C++ を選び、開発効率を重視する際には Python などのスクリプト言語を選ぶといった、性能と生産性のどちらを取るかという二者択一の判断を迫られることが多くありました。Rust は C/C++ に匹敵する高性能を持ちながら、Python などのモダンな言語に見られる表現のしやすさや安全性も備えており、その両立を実現しています。

Rust は、C/C++ と同等の性能を保ちつつ、メモリ安全性や並行性の安全性をコンパイル時に保証することを目指して設計されており、C/C++ の代替としても大きな期待を集めています。

幅広い適用範囲

Rust は、C/C++ に変わるシステムプログラミング言語として注目されがちですが、実は様々な分野で活用できる汎用性の高いプログラミング言語です。

エコシステムの充実

Rust は、言語としての素晴らしい設計思想だけではなく、開発環境やライブラリ（クレートと呼ばれます）関連のエコシステムが非常に充実していることも注目される理由の 1 つです。

例えば、Rust のプロジェクト管理では標準で Cargo というビルドツール兼パッケージマネージャが標準で用意されており、ビルド・テスト・ドキュメント生成の実行、パッケージの依存関係管理などを一貫して行うことができます。

また、Rust のパッケージは crates.io という公式のリポジトリを通じて簡単に検索、導入ができるようになっており、高品質かつ実用的な各種ライブラリが数多く公開されています。このように、実際の開発に必要な機能をすぐに利用できる環境が整っているため、Rust は「学習コストは高いが、開発効率も高い」と評価されることが増えてきています。

大手企業での採用

Rust は、その安全性・性能・開発効率の高さから、近年では Google、Microsoft、Amazon などの大手企業でも採用が進められています。例えば、Microsoft では Windows や Azure（クラウド）などのプロジェクトで Rust を積極的に評価・導入を進めています。このように世界の IT 大手企業が Rust を本番環境に導入し始めていることは、Rust の信頼性や将来性を強く示す動きと言えます。

最も称賛された言語ランキング（2025年調査）

Stack Overflow Developer Survey 2025 の Most Admired Language (最も称賛された言語) として、72.4% のスコアで 2024 年に続いて再び 1 位を獲得しています。これは、現在 Rust を使用する開発者が今後も使いたいと強く思っていることを意味しており、Rust の安全性や充実したエコシステムによる開発が開発者に受け入れられていることがよく分かります。

また、Desired Language (=使用を望まれている言語)では、Python や Javascript といった言語にはやや劣りますが、29.2% で上位となっています。

このように Rust は今後も使用の拡大が十分に期待できる言語です。

ビルドツール兼パッケージマネージャ Cargo は高評価（2025年調査）

Rust の開発時においては、ビルドツール兼パッケージマネージャとして Cargo が使用されています。Stack Overflow Developer Survey 2025 の Cloud development (クラウド開発環境) では、Cargo の Desired は、13.9% と主要なインフラ系ツールと比較すると高い割合ではありませんが、Admired は 70.8% と非常に高いスコアとなっています。これは、実際に使用している開発者の多くが今後も使いたいと考えていることを示しています。

類似するパッケージマネージャーである npm や pip の Admired が 45% 前後であることを考えると Cargo の満足度の高さが際立っています。

このように、Rust は言語自体だけでなく、開発環境 (Cargo を中心としたツールチェーン) も非常に高く評価されていることが分かります。

また、Python では、近年 Rust 製のパッケージマネージャーである uv が注目を集めています。uv は依存解決やロックファイル管理など設計思想において Cargo と共通点が多く、Rust のツール設計思想が他言語にも影響を与えつつあることが感じられます。

Rust の歴史

Rust は、Web ブラウザの Firefox などで知られる Mozilla のエンジニア Graydon Hoare 氏の個人プロジェクトとして 2006 年に始まり、2009 年から Mozilla が公式プロジェクトとして支援するようになりました。

2015 年に Rust 1.0 が正式にリリースされ、以後は安定性と後方互換性を重視した開発が継続されています。2021 年には Rust Foundation が設立され、これを機に Mozilla から独立し、コミュニティによるオープンな体制での開発が進められるようになりました。

また、2018 年からは「エディション」という形で言語仕様の大きな節目が導入されており、本記事執筆時点での最新エディションは、Rust 2024 (バージョン1.85.0以降) です。

Rust はこのように、Mozilla プロジェクトから始まり、オープンなエコシステムへ成長しました。今では世界中の開発者や企業が支える「高性能」と「安全性」を両立する近代的な言語として注目を集めています。

Rust の特徴と強み

ここでは、Rust が注目・評価されている特徴と強みについて概要を紹介していきます。

メモリ安全性（所有権、借用、ライフタイム）

Rust が高く評価されている特徴の一つに「メモリ安全性」を言語仕様のレベルで保証している点があげられます。C/C++ などでは、メモリを十分意識した開発が求められますが、メモリの解放忘れ、解放したメモリへのアクセス（ダングリングポインタ）、バッファオーバーフローなどのシステムに大きく影響する深刻なバグが発生しやすいです。

Rust では、これらの問題をコンパイル時に防ぐ仕組みが言語仕様として備わっています。代表的な「所有権」「借用」「ライフタイム」といった仕組みについて簡単にご紹介します。

所有権（Ownership）

Rust では、変数がデータの所有者であるという所有権の考え方を持っています。他の変数へ所有権が移動すると、元の変数は該当するメモリ上のデータにはアクセスできなくなります。これによりあるメモリ領域へアクセスできる変数が限定されるため、安全にデータを処理できます。

借用（Borrowing）

データの所有権を移動させずにデータを一時的に参照させることを借用といいます。借用には不変参照（読み取り専用）と可変参照（読み書き可）があります。

読み取り専用の不変参照はデータを変更できないため、同時に複数作ることができます。一方で、可変参照は同時に一つしか存在することができず、その間は他の参照や元の変数からのアクセスも禁止されます。これによりデータ競合や不整合のない安全なメモリ管理が実現できます。

ライフタイム（Lifetime）

ライフタイムは、借用に関連する概念であり、どれだけの間で参照ができるのか管理します。ライフタイムの考えにより、元の変数が解放されているのに参照がアクセスするような処理をコンパイル時点で見つけることができ、ダングリングポインタによる不正なメモリへのアクセスを排除できます。

これらの仕組みは少し理解が難しい内容ですが、理解できるとコンパイラが多くの部分を推論、チェックしてくれるため、自然に安全な実装ができるようなものとなっています。

型安全性

Rust は、型によって安全性と開発者の意図を明確に表現できるようになっています。これはHaskell などの関数型言語の影響を受けた設計とも言われています。代表的な例として「値が存在しない可能性」を明示的に扱う Option<T> 型や「成功または失敗」という処理結果を表す Result<T, E> 型などがあります。

Rust では「値がないかもしれない」「エラーが起こるかもしれない」といったケースに対して、型レベルで明示的に扱う必要があり、開発者はこの状況に正面から向き合うことになります。この強力な型システムにより、開発者の見落としによるバグを未然に防ぐことができます。

一方で、こうした明示的な設計はコードの記述量を増やす可能性がありますが、Rust には型推論やパターンマッチングといった仕組みにより、開発者の負担を減らしながら安全性を高めることができるようになっています。

ゼロコスト抽象化

Rust には「ゼロコスト抽象化」という概念があります。これは、抽象的で柔軟なプログラムの書き方をしたとしても、コンパイル後には余計な処理が入らずに高速な処理性能が得られるという設計思想です。

例えば、特徴的なものとしてトレイト (Trait) があります。トレイトは、型に共通する振る舞いを定義するもので、他の言語でいうところのインターフェースに近いようなものです。

このような抽象的な実装においては、他の言語で実行時に動的に決定されて処理されることが多く、処理性能に影響します。一方で、Rust ではコンパイル時に静的に決定します。具体的には、コードの記述されているそれぞれの型に対するコードを生成しています。これにより、高性能かつ安全な実装を実現しています。

非同期処理

Rust では、モダンな言語らしく async / await といった構文による非同期処理をサポートしています。

また、これまでに紹介したような所有権、強力な型システムといった仕組みにより、非同期であってもメモリ安全性を維持しやすく、スレッドやデータ競合に起因するバグを防ぎやすいという点で非常に優れています。

さらに、コンパイル時に処理の安全性が検証されるため、非同期処理にありがちな実行時エラーを未然に防ぎつつ、効率の良い並行処理が可能となっています。

他の言語との違い

Rust は、処理性能で C/C++ に匹敵しながらも安全性が高く、現代的な開発体験を提供してくれる点で、他の多くの言語とは一線を画しています。以下は主要な他の言語との比較です。

Rust と他言語の比較表

比較ポイントの要約

C/C++ との違い

Rust は、C/C++ と同等の性能を持っています。C/C++ では、メモリの手動管理によるバグのリスクが大きいですが、Rust では、コンパイル時にメモリ安全性を言語レベルで保証できるのが大きな違いです。

Python との違い

Python は、非常に書きやすく初心者でも学びやすい言語ですが、実行速度や型安全性に難があります。一方で Rust は、所有権や型に関する理解が必要なため学習コストは高いですが、高速・安全なコードが書けるという違いがあります。

Haskell との違い

Rust は、Haskell のような関数型の良い部分（Option 型、Result 型、パターンマッチングなど）を取り入れつつ、手続き型スタイルにも自然に対応できます。純粋関数型の Haskell ほど抽象度はない分、現実的で実用的なコードを速く書きやすいという違いがあります。

Rust の将来性と課題

Rust は、これまで見てきたように、将来性・安全性・抽象化といった観点で非常にバランスの優れた魅力的な言語です。Rust の将来性と課題についてまとめてみます。

Rust の将来性

大手企業での採用拡大

Google や Microsoft、Amazon などの大手企業での採用も進んでおり、今後も Rust に対応した開発基盤が増えていくと予想されます。

先端的な技術領域での活用

Linux カーネルへの導入や WebAssembly との連携など、先端的な技術領域で活用が広がってきています。

言語仕様・ツールの成熟

コンパイラである rustc やパッケージ管理の Cargo は既に非常に高品質であり、今後も安定的な機能拡張が期待できます。

Rust の課題

学習コストの高さ

所有権やライフタイム、型システムなど、Rust 独自の概念は初学者には難しく、習得までに時間がかかる傾向があります。一方で、C/C++、Java、Python、Haskell 等の複数の言語を触ったことがある人にとっては、Rust の設計思想や言語仕様の良さを感じることができ、非常によい学びになると考えます。

人材や情報の不足

利用者が増加傾向ではあるものの、やはり Python や JavaScript などの主流なエンジニアに比べて Rust エンジニアは少数派です。また、情報についても多くは英語であり、日本語のドキュメントも他言語と比べるとまだ少ないです。ただし、着実に増えては来ています。

一方で、Rust を学ぶことで貴重な知識・技術を持っている技術者として人材価値を生み出すことができる言語であるともいえます。

まとめ

Rust は、C/C++ に匹敵する高いパフォーマンスと Python などのモダンな言語の開発効率を兼ね備えつつ、安全性の高いプログラミングができる現代的なプログラミング言語です。所有権や型安全性といったユニークな仕組みによってバグの少ない堅牢なシステム開発が可能です。

また、エコシステムの充実、大手企業での採用、WebAssembly や非同期処理といった先進技術への対応により、Rust は今後ますます活用の幅が広がっていくと考えられます。

初学者にとっては学習コストがやや高いですが、習得すれば大きな武器となる言語です。本サイトでは、Rust を学びたい方に向けて、分かりやすく実践的な記事を提供していきます。

Rust の魅力をぜひ一緒に体感し、学習に役立てていただければと思います。

あわせて読みたい

Rust プログラミング入門