Rust 3.2 データ型｜20代男性の裏側

Rustにおける値は全て、何らかのデータ型になり、コンパイラがどんなデータが指定されているか知れるので、そのデータの取り扱い方も把握できるというわけです。2種のデータ型のサブセットを見ましょう: スカラー型と複合型です。

Rustは静的型付き言語であることを弁えておいてください。つまり、コンパイル時に全ての変数の型が判明している必要があるということです。コンパイラは通常、値と使用方法に基づいて、使用したい型を推論してくれます。複数の型が推論される可能性がある場合、例えば、第2章の「予想と秘密の数字を比較する」節でparseメソッドを使ってString型を数値型に変換した時のように、複数の型が可能な場合には、型注釈をつけなければいけません。以下のようにですね:


let guess: u32 = "42".parse().expect("Not a number!");    // 数字ではありません！

ここで型注釈を付けなければ、コンパイラは以下のエラーを表示し、これは可能性のある型のうち、どの型を使用したいのかを知るのに、コンパイラがプログラマからもっと情報を得る必要があることを意味します:

error[E0282]: type annotations needed
              (型注釈が必要です)
 --> src/main.rs:2:9
  |
2 |     let guess = "42".parse().expect("Not a number!");
  |         ^^^^^ cannot infer type for `_`
  |               (`_`の型が推論できません)
  |
  = note: type annotations or generic parameter binding required
    (注釈: 型注釈、またはジェネリクス引数束縛が必要です)

他のデータ型についても、様々な型注釈を目にすることになるでしょう。

スカラー型

スカラー型は、単独の値を表します。Rustには主に4つのスカラー型があります: 整数、浮動小数点数、論理値、最後に文字です。他のプログラミング言語でも、これらの型を見かけたことはあるでしょう。 Rustでの動作方法に飛び込みましょう。

整数型

整数とは、小数部分のない数値のことです。第2章で一つの整数型を使用しましたね。u32型です。この型定義は、紐付けられる値が、符号なし整数(符号付き整数はuではなく、iで始まります)になり、 これは、32ビット分のサイズを取ります。表3-1は、Rustの組み込み整数型を表示しています。符号付きと符号なし欄の各バリアント(例: i16)を使用して、整数値の型を宣言することができます。

表3-1: Rustの整数型

大きさ	符号付き	符号なし
8-bit	`i8`	`u8`
16-bit	`i16`	`u16`
32-bit	`i32`	`u32`
64-bit	`i64`	`u64`
arch	`isize`	`usize`

各バリアントは、符号付きか符号なしかを選べ、明示的なサイズを持ちます。符号付きと符号なしは、数値が正負を持つかどうかを示します。つまり、数値が符号を持つ必要があるかどうか(符号付き)、または、絶対に正数にしかならず符号なしで表現できるかどうか(符号なし)です。これは、数値を紙に書き下すのと似ています: 符号が問題になるなら、数値はプラス記号、またはマイナス記号とともに表示されます; しかしながら、その数値が正数であると仮定することが安全なら、符号なしで表示できるわけです。符号付き数値は、 2の補数表現で保持されます(これが何なのか確信を持てないのであれば、ネットで検索することができます。まあ要するに、この解説は、この本の範疇外というわけです)。

各符号付きバリアントは、-(2^{n – 1})以上2^{n – 1} – 1以下の数値を保持でき、ここでnはこのバリアントが使用するビット数です。以上から、i8型は-(2⁷)から2⁷ – 1まで、つまり、-128から127までを保持できます。符号なしバリアントは、0以上2ⁿ – 1以下を保持できるので、 u8型は、0から2⁸ – 1までの値、つまり、0から255までを保持できることになります。

加えて、isizeとusize型は、プログラムが動作しているコンピュータの種類に依存します: 64ビットアーキテクチャなら、64ビットですし、32ビットアーキテクチャなら、32ビットになります。

整数リテラル(訳注: リテラルとは、見たままの値ということ)は、表3-2に示すどの形式でも記述することができます。バイトリテラルを除く数値リテラルは全て、型接尾辞(例えば、57u8)と_を見た目の区切り記号(例えば、1_000)に付加することができます。

表3-2: Rustの整数リテラル

数値リテラル	例
10進数	`98_222`
16進数	`0xff`
8進数	`0o77`
2進数	`0b1111_0000`
バイト (`u8`だけ)	`b'A'`

では、どの整数型を使うべきかはどう把握すればいいのでしょうか？もし確信が持てないのならば、 Rustの基準型は一般的にいい選択肢になります。整数型の基準はi32型です: 64ビットシステム上でも、この型が普通最速になります。isizeとusizeを使う主な状況は、何らかのコレクションにアクセスすることです。

浮動小数点型

Rustにはさらに、浮動小数点数に対しても、2種類の基本型があり、浮動小数点数とは数値に小数点がついたもののことです。 Rustの浮動小数点型は、f32とf64で、それぞれ32ビットと64ビットサイズです。基準型はf64です。なぜなら、現代のCPUでは、f32とほぼ同スピードにもかかわらず、より精度が高くなるからです。

実際に動作している浮動小数点数の例をご覧ください:

ファイル名: src/main.rs

fn main() {
    let x = 2.0; // f64

    let y: f32 = 3.0; // f32
}

浮動小数点数は、IEEE-754規格に従って表現されています。f32が単精度浮動小数点数、 f64が倍精度浮動小数点数です。

数値演算

Rustにも全数値型に期待されうる標準的な数学演算が用意されています: 足し算、引き算、掛け算、割り算、余りです。以下の例では、let文での各演算の使用方法をご覧になれます:

ファイル名: src/main.rs

fn main() {
    // 足し算
    let sum = 5 + 10;

    // 引き算
    let difference = 95.5 - 4.3;

    // 掛け算
    let product = 4 * 30;

    // 割り算
    let quotient = 56.7 / 32.2;

    // 余り
    let remainder = 43 % 5;
}

これらの文の各式は、数学演算子を使用しており、一つの値に評価され、そして、変数に束縛されます。付録BにRustで使える演算子の一覧が載っています。

論理値型

他の多くの言語同様、Rustの論理値型も取りうる値は二つしかありません: trueとfalseです。 Rustの論理値型は、boolと指定されます。例です:

ファイル名: src/main.rs

fn main() {
    let t = true;

    let f: bool = false; // 明示的型注釈付きで
}

論理値を使う主な手段は、条件式です。例えば、if式などですね。if式のRustでの動作方法については、「制御フロー」節で講義します。

文字型

ここまで、数値型のみ扱ってきましたが、Rustには文字も用意されています。Rustのchar型は、言語の最も基本的なアルファベット型であり、以下のコードでその使用方法の一例を見ることができます。 (charは、ダブルクォーテーションマークを使用する文字列に対して、シングルクォートで指定されることに注意してください。)

ファイル名: src/main.rs

fn main() {
    let c = 'z';
    let z = 'ℤ';
    let heart_eyed_cat = '😻';    //ハート目の猫
}

Rustのchar型は、ユニコードのスカラー値を表します。これはつまり、アスキーよりもずっとたくさんのものを表せるということです。アクセント文字; 中国語、日本語、韓国語文字; 絵文字; ゼロ幅スペースは、全てRustでは、有効なchar型になります。ユニコードスカラー値は、 U+0000からU+D7FFまでとU+E000からU+10FFFFまでの範囲になります。ところが、「文字」は実はユニコードの概念ではないので、文字とは何かという人間としての直観は、 Rustにおけるchar値が何かとは合致しない可能性があります。この話題については、第8章の「文字列」で詳しく議論しましょう。

複合型

複合型により、複数の値を一つの型にまとめることができます。Rustには、 2種類の基本的な複合型があります: タプルと配列です。

タプル型

タプルは、複数の型の何らかの値を一つの複合型にまとめ上げる一般的な手段です。

タプルは、丸かっこの中にカンマ区切りの値リストを書くことで生成します。タプルの位置ごとに型があり、タプル内の値はそれぞれ全てが同じ型である必要はありません。今回の例では、型注釈をあえて追加しました:

ファイル名: src/main.rs

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

変数tupは、タプル全体に束縛されています。なぜなら、タプルは、一つの複合要素と考えられるからです。タプルから個々の値を取り出すには、パターンマッチングを使用して分解することができます。以下のように:

ファイル名: src/main.rs

fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("The value of y is: {}", y);
}

このプログラムは、まずタプルを生成し、それを変数tupに束縛しています。それからletとパターンを使ってtup変数の中身を3つの個別の変数(x、y、zですね)に変換しています。この過程は、分配と呼ばれます。単独のタプルを破壊して三分割しているからです。最後に、プログラムはy変数の値を出力し、6.4と表示されます。

パターンマッチングを通しての分配の他にも、アクセスしたい値の番号をピリオド(.)に続けて書くことで、タプルの要素に直接アクセスすることもできます。例です:

ファイル名: src/main.rs

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let five_hundred = x.0;

    let six_point_four = x.1;

    let one = x.2;
}

このプログラムは、新しいタプルxを作成し、添え字アクセスで各要素に対して新しい変数も作成しています。多くのプログラミング言語同様、タプルの最初の添え字は0です。

配列型

配列によっても、複数の値のコレクションを得ることができます。タプルと異なり、配列の全要素は、同じ型でなければなりません。Rustの配列は、他の言語と異なっています。Rustの配列は、固定長なのです: 一度宣言されたら、サイズを伸ばすことも縮めることもできません。

Rustでは、配列に入れる要素は、角かっこ内にカンマ区切りリストとして記述します:

ファイル名: src/main.rs

fn main() {
    let a = [1, 2, 3, 4, 5];
}

配列は、ヒープよりもスタック(スタックとヒープについては第4章で詳つまびらかに議論します)にデータのメモリを確保したい時、または、常に固定長の要素があることを確認したい時に有効です。ただ、配列は、ベクタ型ほど柔軟ではありません。ベクタは、標準ライブラリによって提供されている配列と似たようなコレクション型で、こちらは、サイズを伸縮させることができます。配列とベクタ型、どちらを使うべきか確信が持てない時は、おそらくベクタ型を使うべきです。第8章でベクタについて詳細に議論します。

ベクタ型よりも配列を使いたくなるかもしれない例は、1年の月の名前を扱うプログラムです。そのようなプログラムで、月を追加したり削除したりすることまずないので、配列を使用できます。常に12個要素があることもわかってますからね:


let months = ["January", "February", "March", "April", "May", "June", "July",
              "August", "September", "October", "November", "December"];

配列の要素にアクセスする

配列は、スタック上に確保される一塊のメモリです。添え字によって、配列の要素にこのようにアクセスすることができます:

ファイル名: src/main.rs

fn main() {
    let a = [1, 2, 3, 4, 5];

    let first = a[0];
    let second = a[1];
}

この例では、firstという名前の変数には1という値が格納されます。配列の[0]番目にある値が、それだからですね。secondという名前の変数には、配列の番目の値2が格納されます。

配列要素への無効なアクセス

配列の終端を越えて要素にアクセスしようとしたら、どうなるでしょうか？先ほどの例を以下のように変えたとすると、コンパイルは通りますが、実行するとエラーで終了します:

ファイル名: src/main.rs

fn main() {
    let a = [1, 2, 3, 4, 5];
    let index = 10;

    let element = a[index];

    println!("The value of element is: {}", element);   // 要素の値は{}です
}

このコードをcargo runで走らせると、以下のような結果になります:

$ cargo run
   Compiling arrays v0.1.0 (file:///projects/arrays)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31 secs
     Running `target/debug/arrays`
thread '<main>' panicked at 'index out of bounds: the len is 5 but the index is
 10', src/main.rs:6
スレッド'<main>'は'範囲外アクセス: 長さは5ですが、添え字は10でした', src/main.rs:6
でパニックしました
note: Run with `RUST_BACKTRACE=1` for a backtrace.

コンパイルでは何もエラーが出なかったものの、プログラムは実行時エラーに陥り、正常終了しませんでした。要素に添え字アクセスを試みると、言語は、指定されたその添え字が配列長よりも小さいかを確認してくれます。添え字が配列長よりも大きければ、言語はパニックします。 パニックとは、プログラムがエラーで終了したことを表すRust用語です。

これは、実際に稼働しているRustの安全機構の最初の例になります。低レベル言語の多くでは、この種のチェックは行われないため、間違った添え字を与えると、無効なメモリにアクセスできてしまいます。 Rustでは、メモリアクセスを許可し、処理を継続する代わりに即座にプログラムを終了することで、この種のエラーからプログラマを保護しています。Rustのエラー処理については、第9章でもっと議論します。

Rust 3.2 データ型

スカラー型

整数型

浮動小数点型

数値演算

論理値型

文字型

複合型

タプル型

配列型

配列の要素にアクセスする

配列要素への無効なアクセス

そろそろ守りに入ろうか。

Thena

cake-bnbはどこで運用するのが最適なのか？