ホーム / Rust /

Rustのタプル入門！基本から実践まで初心者向けに徹底解説

2025年4月20日日曜日

Rust

この記事では、プログラミング言語RustにおけるRustのタプルについて、基本からしっかり解説していきます！

配列とはちょっと違う、でもとっても便利なタプルの世界を覗いてみませんか？

複数の値をサッとまとめたい時、関数の結果をいくつか返したい時、タプルがきっとあなたのコーディングを助けてくれるはずです。

なんだか難しそう？大丈夫！この記事を読めば、タプルの使い方をばっちり理解できるよう、分かりやすく説明します。

この記事で学べること

  • Rustのタプルって何なのか、基本的な考え方
  • タプルの作り方（宣言と初期化のしかた）
  • タプルの中身（要素）を取り出す方法
  • 実際のコードでタプルがどう役立つかの具体例
  • タプルを使う時に気をつけること

Rustのタプルとは？～複数の値を手軽にまとめる基本を理解～

さて、まず「タプル」って一体何者なんでしょう？

簡単に言うと、タプルはいくつかの値をひとまとめにして扱える箱のようなものです。
しかも、その箱の中には、数値（整数や小数）、文字列、真偽値（true/false）みたいに、違う種類のデータ（型）を一緒に入れることができるんです。

例えば、人の名前（文字列）と年齢（整数）をセットで扱いたい、なんて時に便利ですね。

配列（Array）も複数の値をまとめられますが、配列は基本的に同じ種類のデータしか入れられません。

構造体（Struct）も違う種類のデータをまとめられますが、事前に「こういう名前でこういう型のデータが入りますよ」と設計図（定義）をしっかり書く必要があります。

その点、タプルはもっと手軽に、一時的に複数の値をまとめたい時にサッと使えるのが魅力んです。

特に関数から複数の結果を返したい時なんかには、タプルが大活躍しますよ！

Rustのタプルの基本的な書き方（宣言と初期化）

じゃあ、実際にRustのコードでタプルをどうやって作るのか見ていきましょう。

タプルを作るのはとっても簡単！丸括弧 `()` で囲んで、中にカンマ `,` で区切って値を入れるだけです。

let my_tuple = (500, 6.4, "Hello"); // 整数、浮動小数点数、文字列をまとめたタプル

上の例では、`my_tuple` という変数に、`500` (整数)、`6.4` (浮動小数点数)、`"Hello"` (文字列) という3つの値を持つタプルを入れています。

Rustは賢いので、それぞれの値から「これは整数だな」「これは文字列だな」と型を自動で推測（型推論）してくれます。

もちろん、自分で型をはっきり指定（型アノテーション）することもできますよ。

書き方（型アノテーションあり）:

let my_typed_tuple: (i32, f64, &str) = (500, 6.4, "Hello");

こう書くと、`my_typed_tuple` は「32ビット整数、64ビット浮動小数点数、文字列スライス」の組である、ということがより明確になりますね。

まあ、最初は型推論に任せても大丈夫なことが多いですよ！

様々なデータ型の値を組み合わせてみよう

タプルのいいところは、本当に色々な型のデータを自由に組み合わせられる点です。
例えば、ゲームキャラクターの情報をタプルで表現してみましょうか。

fn main() {
    // 名前(文字列)、レベル(整数)、HP(整数)、アクティブか(真偽値)
    let player_info = ("Hero", 10, 150, true);

    println!("プレイヤー名: {}", player_info.0);
    println!("レベル: {}", player_info.1);
    println!("HP: {}", player_info.2);
    println!("アクティブ状態: {}", player_info.3);
}

表示結果

プレイヤー名: Hero
レベル: 10
HP: 150
アクティブ状態: true

このように、文字列、整数、真偽値といった異なる型のデータを一つのタプル `player_info` にまとめることができました。

ごちゃごちゃしがちな情報をスッキリまとめられるのは嬉しいですね。（値へのアクセス方法は後で詳しく説明します！）

要素が1つのタプルとユニット型 `()`

ここでちょっと面白い話を。
タプルは複数の値を入れるのが普通ですが、実は要素が1つだけのタプルも作れます。

ただし、ちょっとした注意点があります。要素が1つのタプルを作る時は、値の後ろにカンマ `,` を付ける必要があるんです。

書き方（要素が1つのタプル）

let single_element_tuple = (500,); // ← このカンマが重要！
let just_a_number_in_parentheses = (500); // これはタプルではなく、ただの数値500

// println!("{}", single_element_tuple.0); // これはOK
// println!("{}", just_a_number_in_parentheses.0); // これはエラー！ タプルじゃないから

なぜカンマが必要かというと、` (500) ` だけだと、計算の優先順位を変えるための普通の括弧なのか、タプルなのか区別がつかないからです。カンマを付けることで「これは要素1つのタプルですよ！」とRustコンパイラに教えてあげるわけですね。

さらに、要素が全くないタプルも存在します。それが `()` です。
これは「ユニット型」と呼ばれていて、値がないことを示す特別な型です。

関数が何も返さない（他の言語でいうvoidのようなもの）場合、Rustでは内部的にこのユニット型 `()` が返されているんですよ。今は「ふーん、そういうのもあるんだ」くらいでOKです。

Rustのタプルの値へのアクセス方法をマスターしよう

タプルを作ったはいいけど、中の値を取り出せないと意味がないですよね！
タプルの中の要素にアクセスするには、主に2つの方法があります。

  • インデックス（番号）を使ってアクセスする
  • パターンマッチ（分割束縛）で変数に取り出す

どちらも便利なので、状況に応じて使い分けられるようになりましょう！

インデックスを使ったアクセス（ドット `.` + 数値）

一番シンプルで直感的なのが、インデックスを使う方法です。
タプルの変数名の後にドット `.` を付けて、その後に `0` から始まる番号を指定すると、対応する要素を取り出せます。

fn main() {
    let my_tuple = (10, "Apple", true);

    let number = my_tuple.0; // 0番目の要素（10）を取り出す
    let fruit = my_tuple.1; // 1番目の要素（"Apple"）を取り出す
    let flag = my_tuple.2;  // 2番目の要素（true）を取り出す

    println!("数値: {}", number);
    println!("果物: {}", fruit);
    println!("フラグ: {}", flag);
}

ソースコードの表示結果:

数値: 10
果物: Apple
フラグ: true

注意点は、インデックスが `0` から始まること！ プログラミングではよくあるお約束ですね。
そして、タプルに存在しないインデックス（例えば上の例で `my_tuple.3` ）を指定しようとすると、プログラムをコンパイルする時にエラーになります。実行前に間違いを見つけられるのはRustの安全なところです。

パターンマッチ（分割束縛）でタプルの値をまとめて取り出す

もう一つのアクセス方法が、パターンマッチを使った「分割束縛（destructuring）」です。
`let` を使って、タプルの形に合わせて変数を用意すると、各要素がそれぞれの変数に一気に代入されます。言葉だと難しいので、コードを見てみましょう。

fn main() {
    let point = (3, 5); // (x, y) 座標を表すタプル

    // パターンマッチで要素を変数 x と y に束縛する
    let (x, y) = point;

    println!("X座標: {}, Y座標: {}", x, y);

    // インデックスでアクセスする場合（比較用）
    // let x_index = point.0;
    // let y_index = point.1;
    // println!("X座標: {}, Y座標: {}", x_index, y_index);
}

表示結果

X座標: 3, Y座標: 5

どうでしょう？ `let (x, y) = point;` の一行で、`point.0` が `x` に、`point.1` が `y` に代入されました。インデックスで一つずつ取り出すよりも、コードがスッキリして読みやすくなることが多いです。

もし、タプルの一部の要素しか必要ない場合は、いらない要素に対応する部分をアンダースコア `_` にすることで、その値を無視できます。

ソースコード（一部だけ取り出す例）

fn main() {
    let user_data = ("Alice", 30, "Engineer");

    // 名前だけ必要で、年齢と職業は無視したい場合
    let (name, _, _) = user_data;

    println!("名前: {}", name);
}

表示結果

名前: Alice

アンダースコア `_` は「この場所の値は使わないよ」という目印として覚えておくと便利ですよ。

Rustのタプルの実践的な使い方

基本的な使い方がわかったところで、タプルが実際のプログラミングでどんな風に役立つのか、具体例を見ていきましょう。

「へぇ、こんな使い方ができるんだ！」と思ってもらえたら嬉しいです。

関数の戻り値として複数の値を返す

Rustの関数は、基本的には一つの値しか返すことができません。
でも、関数の処理結果として複数の情報を返したい場面って、結構ありますよね？

例えば、計算結果とその計算が成功したかどうか、とか。座標(x, y)を返すとか。
そんな時、タプルを使えば、複数の値をひとまとめにして返すことができるんです！

// 2つの整数を受け取り、その合計と積をタプルで返す関数
fn calculate(a: i32, b: i32) -> (i32, i32) {
    let sum = a + b;
    let product = a * b;
    (sum, product) // 合計と積をタプルにして返す
}

fn main() {
    let num1 = 5;
    let num2 = 3;

    // 関数の戻り値（タプル）を受け取る
    let result_tuple = calculate(num1, num2);

    // インデックスでアクセス
    println!("{} と {} の合計: {}", num1, num2, result_tuple.0);
    println!("{} と {} の積: {}", num1, num2, result_tuple.1);

    // 分割束縛で受け取ることもできる
    let (s, p) = calculate(num1, num2);
    println!("（分割束縛）合計: {}, 積: {}", s, p);
}

表示結果

5 と 3 の合計: 8
5 と 3 の積: 15
（分割束縛）合計: 8, 積: 15

`calculate` 関数は、戻り値の型として `(i32, i32)` を指定しています。これは「整数と整数のペア（タプル）を返しますよ」という意味です。

関数の最後で `(sum, product)` のように書くだけで、タプルを返すことができます。わざわざ戻り値用の構造体を定義しなくても、手軽に複数の値を返せるのはタプルの大きな利点ですね。

複数の値を一時的にまとめて扱う

プログラムを書いていると、「ちょっとの間だけ、この値とあの値をセットで扱いたいな」という場面が出てくることがあります。

例えば、リストにある複数のデータ（名前と年齢とか）を処理していく時などです。
そんな時も、タプルが手軽なデータの入れ物として役立ちます。

fn main() {
    // (名前, 点数) のタプルのベクター(可変長配列)
    let scores = vec![
        ("Alice", 85),
        ("Bob", 92),
        ("Charlie", 78),
    ];

    // 各生徒の点数をチェックするループ
    for student_score in scores {
        // 分割束縛で名前と点数を取り出す
        let (name, score) = student_score;

        if score >= 80 {
            println!("{} さんは {} 点で合格です！", name, score);
        } else {
            println!("{} さんは {} 点です。", name, score);
        }
    }
}

表示結果

Alice さんは 85 点で合格です！
Bob さんは 92 点で合格です！
Charlie さんは 78 点です。

この例では、生徒の名前（文字列）と点数（整数）をペアにしたタプル `("Alice", 85)` などを `Vec`（ベクター、可変長の配列のようなもの）に入れています。

ループの中で `let (name, score) = student_score;` のように分割束縛を使うことで、各生徒の名前と点数を簡単に取り出して処理できていますね。

わざわざ `Student` 構造体を作るほどでもない、ちょっとしたデータの組を扱うのにタプルはぴったりです。

Rustのタプルを使う上での注意点

手軽で便利なタプルですが、いくつか知っておきたい特性や注意点があります。

これを知っておかないと、「あれ、思ったのと違うぞ？」となるかもしれないので、しっかり押さえておきましょう。

  • 要素の数は変えられない（固定長）
    一度タプルを作ったら、後から要素を追加したり削除したりすることはできません。例えば `(1, 2)` というタプルを `(1, 2, 3)` に変えることはできないのです。要素数を変えたい場合は、配列やベクター（Vec）を使いましょう。
  • 要素の型も固定
    タプルを作った時に決まった各要素の型は、後から変えることはできません。`(10, "Apple")` というタプルの最初の要素に文字列を入れたり、2番目の要素に数値を入れたりすることはできません。
  • ループで直接要素を回せない
    配列やベクターのように、`for` ループを使ってタプルの要素を順番に処理する、ということは直接はできません。各要素にはインデックス `tuple.0`, `tuple.1`... や分割束縛でアクセスする必要があります。

タプルは、そのシンプルさと引き換えに、こうした制約を持っています。

データ構造が決まっていて、後から変更する必要がない場合に特に有効なデータ構造と言えるでしょう。

【まとめ】Rustのタプルを理解して活用しよう！

お疲れ様でした！今回はRustのタプルについて、基本的なところから実践的な使い方まで見てきましたね。

ポイントをまとめると…

  • タプルは複数の、異なる型の値をひとまとめにできる。
  • 作り方は簡単！ `()` で囲んで `,` で区切るだけ。
  • 値の取り出しはインデックス `tuple.0` か、分割束縛 `let (a, b) = tuple;` で。
  • 関数の戻り値で複数の値を返すのに便利。
  • 一度作ると要素数や型は変えられない固定長。

タプルは、Rustプログラミングの基本的な道具箱に入っている、とても便利な機能です。
特に、一時的に関連するデータをまとめたい時や、関数の戻り値としてサッと複数の値を返したい時に、その手軽さが光ります。

配列や構造体といった他のデータ構造との違いも意識しながら、適切な場面でタプルを活用できるようになると、あなたのRustコードはもっと読みやすく、効率的になるはずです。

【関連記事】
Rustとは？いま学ぶべき理由と特徴や始め方を詳しく解説

このブログを検索
  • ()

自己紹介

自分の写真
リモートワークでエンジニア兼Webディレクターとして活動しています。プログラミングやAIなど、日々の業務や学びの中で得た知識や気づきをわかりやすく発信し、これからITスキルを身につけたい人にも役立つ情報をお届けします。 note → https://note.com/yurufuri X → https://x.com/mnao111

QooQ