Rust 基礎系列 #3: Rust 中的數據類型

在 上一篇 關於 Rust 編程語言的文章中，我們提到了變數、常量和 遮蔽 shadowing 。

現在來講解數據類型是再自然不過的了。

數據類型是什麼？

將這個辭彙展開些單詞的順序改變一下你就會得到答案了；「數據類型」 -> 「數據的類型」。

計算機使用 0 和 1 來存儲數據，但是為了讓數據在讀取時有意義，我們使用數據類型來表示這些 0 和 1 的含義。

Rust 有兩種數據類型：

• 標量數據類型：只能存儲單個值的類型。
• 複合數據類型：可以存儲多個值，甚至是不同類型的值。

在本文中，我將講解標量數據類型。我將在下一篇文章中講解第二類數據類型。

接下來是 Rust 中四種主要標量數據類型的簡要概述：

• 整型：存儲整數。有每種特定情況下使用的子類型。
• 浮點數：存儲帶有小數部分的數字。有兩種基於大小的子類型。
• 字元：使用 UTF-8 編碼存儲單個字元。（是的，你可以在字元中存儲表情符號*。）
• 布爾值： 存儲 true 或 false。（給那些無法就 0 是 true 還是 0 是 false 達成一致的開發者。）

整型

在編程語言中，整型指的是一個整數。Rust 中的整型要麼是有符號的，要麼是無符號的。無符號整型只能存儲 0 和正數，而有符號整型可以存儲負數、0 和正數。

? 一個有符號整型的範圍從 -(2<sup> n-1</sup>) 開始，以 (2<sup> n-1</sup>)-1 結束。同樣，無符號整型的範圍從 0 開始，以 (2<sup> n</sup>)-1 結束。

這是根據符號和長度可用的整型：

正如你所見，Rust 有 8、16、32、64 甚至 128 位的有符號和無符號整型！

使用 *size 的整型根據計算機的架構而變化。在 8 位微控制器上，它是 *8，在 32 位的舊計算機上，它是 *32，在現代 64 位系統上，它是 *64。

使用 *size 是為了存儲與內存（這與裸機相關）有關的數據，比如指針、偏移量等。

? 當你沒有顯式地指定整型的子類型時，Rust 編譯器會默認推斷為 i32。顯然，如果值比 i32 能存儲的值大或小，Rust 編譯器會禮貌地報錯並要求你手動指定類型。

Rust 不僅允許你以十進位形式存儲整數，還允許你以二進位、八進位和十六進位形式存儲整數。

為了更好的可讀性，你可以使用下劃線 _ 來代替逗號來書寫/讀取大數。

fn main() {
    let bin_value = 0b100_0101; // 使用前綴「0b」表示二進位
    let oct_value = 0o105; // 使用前綴「0o」表示八進位
    let hex_value = 0x45; // 使用前綴「0x」表示十六進位
    let dec_value = 1_00_00_000; // 和寫一克若（1,00,00,000）一樣

    println!("二進位值: {bin_value}");
    println!("八進位值: {oct_value}");
    println!("十六進位值: {hex_value}");
    println!("十進位值: {dec_value}");
}

我使用二進位、八進位和十六進位分別將十進位數 69 存儲在變數 bin_value、oct_value 和 hex_value 中。在變數 dec_value 中，我存儲了數字 1 克若 1 Crore （一千萬），並且使用了下劃線替代逗號，這是印度的書寫系統。對於那些更熟悉國際計數系統的人來說，你可以將其寫成 10_000_000。

在編譯並運行這個二進位文件後，我得到了如下輸出：

二進位值: 69
八進位值: 69
十六進位值: 69
十進位值: 10000000

浮點數

浮點數是一種存儲帶有小數部分的數字的數據類型。

與 Rust 中的整型不同，浮點數只有兩種子類型：

• f32: 單精度浮點數類型
• f64: 雙精度浮點數類型

和 Rust 中的整型一樣，當 Rust 推斷一個變數的類型時，如果它看起來像一個浮點數，那麼它就會被賦予 f64 類型。這是因為 f64 類型比 f32 類型有更高的精度，並且在大多數計算操作中幾乎和 f32 類型一樣快。請注意，浮點數據類型（f32 和 f64）都是有符號的。

? Rust 編程語言按照 IEEE 754 二進位浮點數表示與算術標準存儲浮點數。

fn main() {
    let pi: f32 = 3.1400; // f32
    let golden_ratio = 1.610000; // f64
    let five = 5.00; // 小數點表示它必須被推斷為浮點數
    let six: f64 = 6.; // 儘管類型說明被顯式的添加了，小數點也是**必須**的

    println!("pi: {pi}");
    println!("黃金比例: {golden_ratio}");
    println!("五: {five}");
    println!("六: {six}");
}

仔細看第 5 行。儘管我已經為變數 six 指定了類型，但我必須至少加上一個小數點。小數點之後有什麼就由你決定了。

程序的輸出是相當可預測的... 嗎？

pi: 3.14
黃金比例: 1.61
五: 5
六: 6

在上面的輸出中，你可能已經注意到，當顯示變數 pi、golden_ratio 和 five 中存儲的值時，我在變數聲明時在結尾增加的零已經消失了。

就算這些零沒有被 移除，它們也會在通過 println 宏輸出值時被省略。所以，不，Rust 沒有篡改你的變數值。

字元

你可以在一個變數中存儲一個字元，類型是 char。像 80 年代的傳統編程語言一樣，你可以存儲一個 ASCII 字元。但是 Rust 還擴展了字元類型，以存儲一個有效的 UTF-8 字元。這意味著你可以在一個字元中存儲一個表情符號 ?

? 一些表情符號實際上是兩個已有表情符號的組合。一個很好的例子是「燃燒的心」表情符號：❤️‍?。這個表情符號是通過使用 零寬度連接器 來組合兩個表情符號構成的：❤️ + ? = ❤️‍?

Rust 的字元類型無法存儲這樣的表情符號。

fn main() {
    let a = 'a';
    let p: char = 'p'; // 帶有顯性類型說明
    let crab = '?';

    println!("Oh look, {} {}! :{}", a, crab, p);
}

正如你所見，我已經將 ASCII 字元 'a' 和 'p' 存儲在變數 a 和 p 中。我還在變數 crab 中存儲了一個有效的 UTF-8 字元，即螃蟹表情符號。然後我列印了存儲在每個變數中的字元。

這是輸出：

Oh look, a ?! :p

布爾值

在 Rust 中，布爾值類型只存儲兩個可能的值之一：true 或 false。如果你想顯性指定類型，請使用 bool。

fn main() {
    let val_t: bool = true;
    let val_f = false;

    println!("val_t: {val_t}");
    println!("val_f: {val_f}");
}

編譯並執行上述代碼後，結果如下：

val_t: true
val_f: false

額外內容：顯性類型轉換

在上一篇講述 Rust 編程語言中的變數的文章中，我展示了一個非常基礎的 溫度轉換程序。在那裡，我提到 Rust 不允許隱式類型轉換。

但這不代表 Rust 也不允許 顯性 類型轉換 ; )

要進行顯性類型轉換，使用 as 關鍵字，後面跟著要轉換的數據類型。

這是一個示常式序：

fn main() {
    let a = 3 as f64; // f64
    let b = 3.14159265359 as i32; // i32

    println!("a: {a}");
    println!("b: {b}");
}

在第二行，我沒有使用 3.0，而是在 3 後面寫上 as f64，以表示我希望編譯器將 3（一個整數）轉換為 64 位浮點數的類型轉換。第三行也是一樣。但是這裡，類型轉換是有損的。這意味著小數部分 完全消失。它不是存儲為 3.14159265359，而是存儲為簡單的 3。

程序的輸出可以驗證這一點：

a: 3
b: 3

總結

本文介紹了 Rust 中的原始/標量數據類型。主要有四種這樣的數據類型：整型、浮點數、字元和布爾值。

整型用於存儲整數，它們有幾種子類型，基於它們是有符號還是無符號以及長度。浮點數用於存儲帶有小數的數字，根據長度有兩種子類型。字元數據類型用於存儲單個有效的 UTF-8 編碼字元。最後，布爾值用於存儲 true 或 false 值。

在下一章中，我將討論數組和元組等複合數據類型。敬請關注。

（題圖：MJ/c0c49e15-cc9d-4eef-8e52-2f0d62294965）

via: https://itsfoss.com/rust-data-types/

作者：Pratham Patel 選題：lkxed 譯者：Cubik65536 校對：wxy

本文由 LCTT 原創編譯，Linux中國 榮譽推出

本文轉載來自 Linux 中國: https://github.com/Linux-CN/archive