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 プログラミング入門

プログラムを実行していく際には、ある値をコンピューターのメモリ上に格納し、取り出しながら様々な処理を実行していきます。ある値を含む場所のメモリをオブジェクトと呼びます。そして、そのオブジェクトを識別するための識別子が必要です。

ある値（オブジェクト）を識別子（名前）に束縛することで、変数（variable）を定義します。また、プログラムを実行している最中に値が変更されることのない、あらかじめ決められた値は定数（constant）と呼ばれます。

この記事では、Rustにおける変数と定数の扱いや使い方について解説します。

Rustの変数は基本イミュータブルで変更不可

Rustで最初に覚えておいてほしいことは「変数は基本イミュータブルで変更ができない」ということです。他のプログラミング言語を学んできた人は変数の値を変えられることが普通であることが多かったと思いますし、変数という名前から考えると違和感を覚えるかもしれません。

例えば、Haskellなどの関数型プログラミング言語は、変数がイミュータブルで、関数も副作用を持たないように設計されているため、参照透過性が高く、同じ入力には常に同じ出力が保証されます。変数の値が変更できないことは、不便に思うかもしれないですが、一方で値が変わらないことが保証されるため、バグがないプログラムを書くことが可能になります。

Rustでの変数定義と利用の例を見てみましょう。

[immutable.rs]

fn main() {
    let x = 5;
    println!("xの値: {}", x);

    // 以下はエラーとなる
    // x = 6;
}

【コンパイル結果】
error[E0384]: cannot assign twice to immutable variable `x`
 --> examples\immutable.rs:7:5
  |
2 |     let x = 5;
  |         - first assignment to `x`
...
7 |     x = 6;
  |     ^^^^^ cannot assign twice to immutable variable
  |
help: consider making this binding mutable
  |
2 |     let mut x = 5;
  |         +++

Rustでは、変数の定義に let キーワードを使い、変数 x に = で値を設定します。「let x = 5;」のような記載を「文」といい、Rustでは、値を束縛するという表現をします。また、変数はスネークケース（snake_case）という小文字単語をアンダースコアでつなぐ形式にするのが通例です。

上記例で一度定義した x に対して、x = 6; という形で値を変更した場合には、コンパイルの際に「cannot assign twice to immutable variable」というようなエラーが発生します(コメントアウトしているため外して実行してみてください)。これは、イミュータブルな変数に2度、値を設定しようとしているというエラーです。

ただし、コンパイル結果の help: の記載を見てみると分かりますが、Rustでは値を変更するための方法があります。以降ではその方法を見てみましょう。

変更するにはミュータブル mut の指定が必要

Rustで値を変更する変数の場合には、let mut という形で mut キーワードを指定します。

[mutable.rs]

fn main() {
    // ミュータブルな変数として定義する
    let mut x = 5;
    println!("xの値: {}", x);

    // ミュータブルな変数に値を再度設定する
    x = 6;
    println!("xの値: {}", x);
}

【実行結果】
xの値: 5
xの値: 6

上記の結果を見てみると分かるように、今度は x の値を変更してもエラーは発生せずに実行を完了することができます。

シャドーイング

Rustでは、一度定義した変数を再度 let を用いて再定義することができます。このことを「シャドーイング（shadowing）」と言います。

シャドーイングの基本

以下の例では、一度 let x = 5; で定義した変数 x について、再度 let x = 10; で再定義しています。

[shadowing.rs]

fn main () {
    let x = 5;
    println!("xの値: {}", x);

    // xをシャドーイングする
    let x = 10;
    println!("xの値: {}", x);
}

【実行結果】
xの値: 5
xの値: 10

上記で見たように一度定義した x の値を変更することは、イミュータブルな性質から不可能でした。しかし、今回の例での let を使った再定義は問題なくできます。この時に、もともと定義していた x = 5; を後の定義が覆い隠してしまうことから、シャドーイング（shadowing）と呼ばれるわけです。

同じスコープ内では、前に定義した x = 5; の値は二度と使えなくなるため、スコープを抜けたタイミングで 5 が格納されているメモリ領域は自動で解放されます。

異なるスコープでのシャドーイング

異なるスコープでシャドーイングによる変数の再定義をした場合に、どのような挙動になるのかを以下の例で確認してみましょう。

[shadowing_other_scope.rs]

fn main () {
    let x = 5;
    println!("xの値: {}", x);
    {
        // 異なるスコープでシャドーイングする
        let x = 10;
        println!("xの値: {}", x);
    }
    println!("xの値: {}", x);
}

【実行結果】
xの値: 5
xの値: 10
xの値: 5

上記例では、let x = 5; で一度定義した変数を一段深いスコープで let x = 10; で再定義しています。このとき、このスコープ内で x の値は 10 ですが、スコープを抜けると外側の x = 5; に戻ります。そのため、println! で 5 が表示されていることが分かります。なお、10 が格納されているメモリは、スコープを抜けた際に解放されます。このように異なるスコープ間でのシャドーイングの挙動はよく理解しておきましょう。

const 定数

Rustで定数を定義するためには、const キーワードを使用して定義します。

定数とはコンパイル時に値が確定しているもので、一度決めたら絶対に変わらない値を定義する際に使用します。例えば、システムで共通に使用するパラメータを定義するような場合です。

定数は、大文字のスネークケース（SNAKE_CASE）で定義するのが通例です。定数は関数内でも定義できますが、実際にはプログラム全体で使う値を定義するために、グローバルに定義されることが多いです。

定数は以下のように定義して使用します。

[constant.rs]

// 定数を定義 (型注釈は必須)
const MAX_USERS: u32 = 100;

fn main () {
    // 定数を利用
    println!("MAX_USERS: {}", MAX_USERS)
}

【実行結果】
MAX_USERS: 100

変数と定数の違いの一つとして、型定義が必須であることがあげられます。変数は型推論がされるため、指定は必須ではありません。上記例では、MAX_USERS: u32 = 100; の : u32 という部分が 32ビットの符号なし整数であることを示しています。Rustの標準的な型については、別途取り上げて説明しようと思います。

また、コンパイル時に決定する性質であることから、動的に確保されるヒープ領域に格納される型（Vec<T>など）での定義もできません。

まとめ

この記事では、Rustにおける変数と定数の基本的な使い方について解説しました。

Rustの変数はデフォルトでイミュータブル（変更不可）であり、安全性を高めるための設計となっています。一方で、mut キーワードを使うことで明示的に可変な変数も定義できるため、安全性と柔軟性のバランスがとられています。

同じ名前の変数を再定義する「シャドーイング」やスコープにより変数の有効範囲が制限される仕組みもRustの所有権やメモリ管理の考え方と密接に関係しています。また、const によってコンパイル時に固定される定数を定義することで、値の意味付けや再利用性を高めることができます。

Rustを学び始めたばかりの段階では、このような「変数と定数の基本的なルール」をしっかり理解しておくと、Rustの中心的な概念である所有権やライフタイムなどについても理解しやすくなります。ぜひ基本をしっかりと押さえておいてください。

あわせて読みたい

Rust プログラミング入門