Rustのプログラミングを学ぶ上で、最初に理解すべき重要な概念が「型システム」です。

Rustは静的型付け言語であり、コンパイル時にすべての変数の型が決定されている必要があります。

特に、言語仕様としてあらかじめ定義されている「プリミティブ型」の理解は不可欠です。

プリミティブ型の中には、単一の値を表す「スカラー型」と、複数の値をまとめる「複合型」が存在します。

この記事では、Rustにおけるプリミティブ型とスカラー型の定義の違いを整理し、それぞれの具体的な特徴について詳しく解説します。

2026年現在のモダンな開発環境においても、これらの基礎知識はパフォーマンス最適化やメモリ安全性を実現するために極めて重要です。

目次 [ close ]
  1. Rustにおけるプリミティブ型の全体像
  2. スカラー型の4つの主要なカテゴリー
    1. 整数型 (Integer Types)
    2. 浮動小数点型 (Floating-Point Types)
    3. 論理値型 (Boolean Type)
    4. 文字型 (Character Type)
  3. プリミティブ型における複合型
    1. タプル型 (Tuple Type)
    2. 配列型 (Array Type)
  4. プリミティブ型とスカラー型の明確な違い
  5. スカラー型とCopyトレイトの関係
  6. まとめ

Rustにおけるプリミティブ型の全体像

Rustのプリミティブ型とは、標準ライブラリではなく言語自体に組み込まれている基本的なデータ型を指します。

プリミティブ型は大きく分けて、「スカラー型」と「複合型」の2つのカテゴリに分類されます。

スカラー型は、たった一つの値を保持する型のことです。

一方で複合型は、複数の値を一つのグループとして扱うことができる型を指します。

多くの初心者が混乱しやすいポイントですが、「プリミティブ型」という大きな枠組みの中に「スカラー型」が含まれているという関係性をまずは押さえておきましょう。

また、プリミティブ型にはスライス(slice)や文字列スライス(str)なども含まれますが、これらはスカラー型には分類されません。

スカラー型の4つの主要なカテゴリー

Rustのスカラー型には、主に4つの種類が存在します。

  • 整数型 (Integer types)
  • 浮動小数点型 (Floating-point types)
  • 論理値型 (Boolean type)
  • 文字型 (Character type)

これらの型はすべて「単一の値」を表しており、メモリ上でのサイズが固定されています。

それぞれの型がどのような特性を持ち、どのような場面で利用されるのかを深掘りしていきましょう。

整数型 (Integer Types)

整数型は、小数点を持たない数値を表すための型です。

Rustでは、符号あり(i)と符号なし(u)の区別があり、さらにビット数によって細かく分類されています。

サイズ符号あり符号なし
8-biti8u8
16-biti16u16
32-biti32u32
64-biti64u64
128-biti128u128
arch (プラットフォーム依存)isizeusize

符号ありの型は、負の数から正の数までの範囲をカバーします。

符号なしの型は、0以上の正の数のみを扱うことができ、その分扱える正の最大値が大きくなります。

特に isize と usize は、プログラムが動作しているコンピュータのアーキテクチャに依存する という特徴があります。

例えば、64ビットのOSであれば64ビットになり、32ビットのOSであれば32ビットになります。

主に配列のインデックス指定や、メモリ上のアドレスを扱う際に usize が多用されます。

Rust
fn main() {
    // 明示的な型指定
    let x: i32 = -42;
    let y: u32 = 100;

    // アーキテクチャ依存の型
    let index: usize = 10;

    println!("x: {}, y: {}, index: {}", x, y, index);
}
実行結果
x: -42, y: 100, index: 10

浮動小数点型 (Floating-Point Types)

Rustにおける浮動小数点型は、小数を含む数値を扱うための型です。

f32 と f64 の2種類が用意されており、デフォルトでは f64 が使用されます。

これは、現代のCPUにおいては f64 が f32 とほぼ同等の速度で処理可能であり、かつ精度が高いため です。

どちらの型も IEEE 754 規格に準拠しています。

Rust
fn main() {
    let f_default = 2.0; // デフォルトは f64
    let f_small: f32 = 3.14; // 明示的に f32 を指定

    println!("f64: {}, f32: {}", f_default, f_small);
}
実行結果
f64: 2, f32: 3.14

論理値型 (Boolean Type)

論理値型は bool と呼ばれ、true または false のいずれかの値を取ります。

この型は主に、条件分岐(if文など)の判定材料として利用されます。

論理値型のメモリサイズは1バイトです。

Rust
fn main() {
    let is_rust_fun = true;
    let is_finished: bool = false;

    if is_rust_fun {
        println!("Rustは楽しいです！");
    }
}
実行結果
Rustは楽しいです！

文字型 (Character Type)

Rustの文字型 char は、単一の Unicode スカラー値を表します。

多くの言語の char 型が1バイト(ASCII)であるのに対し、Rustの char 型は4バイトのサイズを持ちます。 これにより、日本語の「あ」や、絵文字のような多バイト文字も単一の char として扱うことが可能です。

リテラルを指定する際は、ダブルクォーテーションではなく、シングルクォーテーション(')を使用します。

Rust
fn main() {
    let c = 'z';
    let z = 'ℤ';
    let heart_eyed_cat = '😻';

    println!("文字: {}, {}, {}", c, z, heart_eyed_cat);
}
実行結果
文字: z, ℤ, 😻

プリミティブ型における複合型

スカラー型が単一の値を扱うのに対し、プリミティブ型には「複合型」も含まれます。

複合型は、複数の値を一つのデータ構造としてまとめる役割を果たします。

主に「タプル」と「配列」の2種類が存在します。

タプル型 (Tuple Type)

タプルは、異なる型の値を一つにまとめることができる便利な型です。

一度宣言すると、そのサイズ(要素数)を自由に変更することはできません。

タプルの要素にアクセスするには、ドット演算子とインデックス番号を使用します。

Rust
fn main() {
    // 異なる型を混在させることができる
    let tup: (i32, f64, u8) = (500, 6.4, 1);

    // パターンマッチングによる分解
    let (x, y, z) = tup;

    // 直接インデックスでアクセス
    println!("タプルの2番目の値: {}", tup.1);
    println!("分解した値 x: {}", x);
}
実行結果
タプルの2番目の値: 6.4
分解した値 x: 500

配列型 (Array Type)

配列は、同じ型の値を複数まとめるための構造です。

タプルとは異なり、配列のすべての要素は同じ型でなければなりません。

また、Rustのプリミティブな配列は固定長であり、宣言時にサイズが確定している必要があります。

要素数が動的に変化する場合は、標準ライブラリの Vector 型を使用しますが、これはプリミティブ型ではありません。

Rust
fn main() {
    // [型; 要素数] という形式で定義
    let a: [i32; 5] = [1, 2, 3, 4, 5];

    // すべて同じ値で初期化
    let b = [0; 3]; // [0, 0, 0] と同じ

    println!("配列 a の最初の要素: {}", a[0]);
    println!("配列 b: {:?}", b);
}
実行結果
配列 a の最初の要素: 1
配列 b: [0, 0, 0]

プリミティブ型とスカラー型の明確な違い

ここまで見てきた通り、プリミティブ型はRust言語の基礎となるデータ型の総称です。

一方でスカラー型は、そのプリミティブ型の中でも「最小単位の単一データ」を指す分類です。

「すべてのスカラー型はプリミティブ型であるが、すべてのプリミティブ型がスカラー型であるとは限らない」という点が重要です。

例えば、配列やタプルはプリミティブ型に含まれますが、複数の要素を持つためスカラー型ではありません。

また、特殊なプリミティブ型として str や [T] (スライス) も存在しますが、これらもスカラーではありません。

この分類を正しく理解することで、Rustのリファレンスを読む際の解像度が大きく向上します。

スカラー型とCopyトレイトの関係

Rustの所有権システムにおいて、スカラー型は非常に特殊な扱いを受けます。

整数型や論理値型などの スカラー型は、デフォルトで「Copyトレイト」を実装しています。

通常、Rustで変数を別の変数に代入すると、所有権が移動(ムーブ)します。

しかし、Copyトレイトを実装している型の場合、代入時にデータのビットコピーが作成されます。

そのため、元の変数も引き続き利用することが可能です。

Rust
fn main() {
    let x = 5;
    let y = x; // i32はスカラー型なのでコピーされる

    println!("x: {}, y: {}", x, y); // 両方使用可能
}

一方で、スカラー型でない型(例えば String 型)などは Copy トレイトを持っていないため、同様の操作をするとムーブが発生します。

プリミティブ型の中でも、複合型であるタプルは、その中身がすべて Copy トレイトを実装している型であれば、自身も Copy トレイトを持ちます。 しかし、一つでも Copy でない型が含まれている場合、そのタプル全体も Copy できなくなる点に注意が必要です。

まとめ

Rustにおける「プリミティブ型」と「スカラー型」の違いについて解説しました。

プリミティブ型は、言語仕様に組み込まれた「整数」「浮動小数点」「論理値」「文字」「タプル」「配列」「スライス」「文字列スライス」などの総称です。

その中でスカラー型は、単一の値を表す「整数」「浮動小数点」「論理値」「文字」の4つを指します。

スカラー型はメモリ上のサイズが固定されており、スタック領域に割り当てられ、効率的なコピーが可能です。

一方で複合型は、これらスカラー型を組み合わせることで、より複雑なデータ構造を表現するために利用されます。

これらの基本的な型の特性を正しく理解することは、Rust特有の「所有権」や「メモリ管理」の概念をマスターするための第一歩となります。

まずは各型のビット数や範囲を意識しながら、適切な型を選択できるよう練習を重ねていきましょう。