基本型別

Rust 每個值都有其確切的資料型別，總的來說可以分為兩類：基本型別和復合型別， 基本型別意味著它們往往是一個最小化原子型別，無法解構為其它型別(一般意義上來說)，由以下組成：

• 數值型別: 有符號整數 (i8, i16, i32, i64, isize)、 無符號整數 (u8, u16, u32, u64, usize) 、浮點數 (f32, f64)、以及有理數、復數
• 字串：字串字面量和字串切片 &str
• 布爾型別： true和false
• 字符型別: 表示單個 Unicode 字符，存盤為 4 個位元組
• 單元型別: 即 () ，其唯一的值也是 ()

型別推導與標注

Rust 是一門靜態型別語言，也就是編譯器必須在編譯期知道我們所有變數的型別，但這不意味著你需要為每個變數指定型別，因為 Rust 編譯器可以根據變數的值和背景關系中的使用方式來自動推匯出變數的型別，但在某些情況下，它無法推匯出變數型別，需要手動去給予一個型別標注

整數

整數是沒有小數部分的數字，之前使用過的 i32 型別，表示有符號的 32 位整數（ i 是英文單詞 integer 的首字母，與之相反的是 u，代表無符號 unsigned 型別），下表顯示了 Rust 中的內置的整數型別：

型別定義的形式統一為：有無符號 + 型別大小(位數)，無符號數表示數字只能取正數，而有符號則表示數字既可以取正數又可以取負數，就像在紙上寫數字一樣：當要強調符號時，數字前面可以帶上正號或負號；然而，當很明顯確定數字為正數時，就不需要加上正號了，有符號數字以補碼形式存盤，

每個有符號型別規定的數字范圍是 -(2n - 1) ~ 2n - 1 - 1，其中 n 是該定義形式的位長度，因此 i8 可存盤數字范圍是 -(27) ~ 27 - 1，即 -128 ~ 127，無符號型別可以存盤的數字范圍是 0 ~ 2n - 1，所以 u8 能夠存盤的數字為 0 ~ 28 - 1，即 0 ~ 255，

此外，isize 和 usize 型別取決于程式運行的計算機 CPU 型別： 若 CPU 是 32 位的，則這兩個型別是 32 位的，同理，若 CPU 是 64 位，那么它們則是 64 位，

整形字面量可以用下表的形式書寫：

這么多型別，有沒有一個簡單的使用準則？答案是肯定的， Rust 整型默認使用 i32，例如 let i = 1，那 i 就是 i32 型別，因此你可以首選它，同時該型別也往往是性能最好的isize 和 usize 的主要應用場景是用作集合的索引，

整型溢位

假設有一個 u8 ，它可以存放從 0 到 255 的值，那么當你將其修改為范圍之外的值，比如 256，則會發生整型溢位，關于這一行為 Rust 有一些有趣的規則：當在 debug 模式編譯時，Rust 會檢查整型溢位，若存在這些問題，則使程式在編譯時 panic(崩潰,Rust 使用這個術語來表明程式因錯誤而退出)，

在當使用 --release 引數進行 release 模式構建時，Rust 不檢測溢位，相反，當檢測到整型溢位時，Rust 會按照補碼回圈溢位（two’s complement wrapping）的規則處理，簡而言之，大于該型別最大值的數值會被補碼轉換成該型別能夠支持的對應數字的最小值，比如在 u8 的情況下，256 變成 0，257 變成 1，依此類推，程式不會 panic，但是該變數的值可能不是你期望的值，依賴這種默認行為的代碼都應該被認為是錯誤的代碼，

要顯式處理可能的溢位，可以使用標準庫針對原始數字型別提供的這些方法：

• 使用 wrapping_* 方法在所有模式下都按照補碼回圈溢位規則處理，例如 wrapping_add
• 如果使用 checked_* 方法時發生溢位，則回傳 None 值
• 使用 overflowing_* 方法回傳該值和一個指示是否存在溢位的布林值
• 使用 saturating_* 方法使值達到最小值或最大值

浮點數

按照存盤大小，把浮點型劃分為 f32 和 f64，其中 f64 是默認的浮點型別，

• f32 又稱為 單精度浮點型，
• f64 又稱為 雙精度浮點型，它是 Rust 默認的浮點型別.

Rust 中不能將 0.0 賦值給任意一個整型，也不能將 0 賦值給任意一個浮點型，

fn main() {
    let x = 2.0; // f64
    let y: f32 = 3.0; // f32
}

_下劃線

當數字很大的時候，Rust 可以用 **(_下劃線) ** ，來讓數字變得可讀性更好，

PLAINTEXT

let price12 =1_000_000;
println!("price12 {}", price12); //輸出 price12 1000000

let price13 =1_000_000.666_123;
println!("price13 {}", price13);//輸出 price13 1000000.666123

浮點數陷阱

浮點數由于底層格式的特殊性，導致了如果在使用浮點數時不夠謹慎，就可能造成危險，有兩個原因：

1. 浮點數往往是你想要數字的近似表達 浮點數型別是基于二進制實作的，但是我們想要計算的數字往往是基于十進制，例如 0.1 在二進制上并不存在精確的表達形式，但是在十進制上就存在，這種不匹配性導致一定的歧義性，更多的，雖然浮點數能代表真實的數值，但是由于底層格式問題，它往往受限于定長的浮點數精度，如果你想要表達完全精準的真實數字，只有使用無限精度的浮點數才行
2. 浮點數在某些特性上是反直覺的 例如大家都會覺得浮點數可以進行比較，對吧？是的，它們確實可以使用 >，>= 等進行比較，但是在某些場景下，這種直覺上的比較特性反而會害了你，因為 f32 ， f64 上的比較運算實作的是 std::cmp::PartialEq 特征(類似其他語言的介面)，但是并沒有實作 std::cmp::Eq 特征，但是后者在其它數值型別上都有定義，說了這么多，可能大家還是云里霧里，用一個例子來舉例：

Rust 的 HashMap 資料結構，是一個 KV 型別的 Hash Map 實作，它對于 K 沒有特定型別的限制，但是要求能用作 K 的型別必須實作了 std::cmp::Eq 特征，因此這意味著你無法使用浮點數作為 HashMap 的 Key，來存盤鍵值對，但是作為對比，Rust 的整數型別、字串型別、布爾型別都實作了該特征，因此可以作為 HashMap 的 Key，

為了避免上面說的兩個陷阱，你需要遵守以下準則：

• 避免在浮點數上測驗相等性
• 當結果在數學上可能存在未定義時，需要格外的小心

fn main() {
    let abc: (f32, f32, f32) = (0.1, 0.2, 0.3);
    let xyz: (f64, f64, f64) = (0.1, 0.2, 0.3);

    println!("abc (f32)");
    println!("   0.1 + 0.2: {:x}", (abc.0 + abc.1).to_bits());
    println!("         0.3: {:x}", (abc.2).to_bits());
    println!();

    println!("xyz (f64)");
    println!("   0.1 + 0.2: {:x}", (xyz.0 + xyz.1).to_bits());
    println!("         0.3: {:x}", (xyz.2).to_bits());
    println!();

    assert!(abc.0 + abc.1 == abc.2);
    assert!(xyz.0 + xyz.1 == xyz.2);
}

輸出如下:

abc (f32)
   0.1 + 0.2: 3e99999a
         0.3: 3e99999a

xyz (f64)
   0.1 + 0.2: 3fd3333333333334
         0.3: 3fd3333333333333

thread 'main' panicked at 'assertion failed: xyz.0 + xyz.1 == xyz.2',
?ch2-add-floats.rs.rs:14:5
note: run with `RUST_BACKTRACE=1` environment variable to display
?a backtrace

對 f32 型別做加法時，0.1 + 0.2 的結果是 3e99999a，0.3 也是 3e99999a，因此 f32下的 0.1 + 0.2 == 0.3通過測驗，但是到了 f64型別時，結果就不一樣了，因為 f64精度高很多，因此在小數點非常后面發生了一點微小的變化，0.1 + 0.2以 4結尾，但是 0.3以結尾，這個細微區別導致 f64下的測驗失敗了，并且拋出了例外，

NaN

對于數學上未定義的結果，例如對負數取平方根 -42.1.sqrt() ，會產生一個特殊的結果：Rust 的浮點數型別使用 NaN (not a number)來處理這些情況，

所有跟 NaN 互動的操作，都會回傳一個 NaN，而且 NaN 不能用來比較，下面的代碼會崩潰：

fn main() {
  let x = (-42.0_f32).sqrt();
  assert_eq!(x, x);
}

出于防御性編程的考慮，可以使用 is_nan() 等方法，可以用來判斷一個數值是否是 NaN ：

fn main() {
    let x = (-42.0_f32).sqrt();
    if x.is_nan() {
        println!("未定義的數學行為")
    }
}

數字運算

// 加法
let sum = 5 + 10;
// 減法
let difference = 95.5 - 4.3;
// 乘法
let product = 4 * 30;
// 除法
let quotient = 56.7 / 32.2;
// 求余
let remainder = 43 % 5;

fn main() {
  // 編譯器會進行自動推導，給予twenty i32的型別
  let twenty = 20;
  // 型別標注
  let twenty_one: i32 = 21;
  // 通過型別后綴的方式進行型別標注：22是i32型別
  let twenty_two = 22i32;

  // 只有同樣型別，才能運算
  let addition = twenty + twenty_one + twenty_two;
  println!("{} + {} + {} = {}", twenty, twenty_one, twenty_two, addition);

  // 對于較長的數字，可以用_進行分割，提升可讀性
  let one_million: i64 = 1_000_000;
  println!("{}", one_million.pow(2));

  // 定義一個f32陣列，其中42.0會自動被推導為f32型別
  let forty_twos = [
    42.0,
    42f32,
    42.0_f32,
  ];

  // 列印陣列中第一個值，并控制小數位為2位
  println!("{:.2}", forty_twos[0]);
}

位運算

Rust的運算基本上和其他語言一樣

fn main() {
    // 二進制為00000010
    let a:i32 = 2;
    // 二進制為00000011
    let b:i32 = 3;

    println!("(a & b) value is {}", a & b);
		// (a & b) value is 2
    println!("(a | b) value is {}", a | b);
		// (a | b) value is 3
    println!("(a ^ b) value is {}", a ^ b);
		// (a ^ b) value is 1
    println!("(!b) value is {} ", !b);
		// (!b) value is -4
    println!("(a << b) value is {}", a << b);
		// (a << b) value is 16
    println!("(a >> b) value is {}", a >> b);
		// (a >> b) value is 0
    let mut a = a;
    // 注意這些計算符除了!之外都可以加上=進行賦值 (因為!=要用來判斷不等于)
    a <<= b;
    println!("(a << b) value is {}", a);
		// (a << b) value is 16
}

序列(Range)

Rust 提供了一個非常簡潔的方式，用來生成連續的數值，例如 1..5，生成從 1 到 4 的連續數字，不包含 5 ；1..=5，生成從 1 到 5 的連續數字，包含 5，它的用途很簡單，常常用于回圈中：

for i in 1..=5 {
    println!("{}",i);
}

最終程式輸出:

1
2
3
4
5

序列只允許用于數字或字符型別，原因是：它們可以連續，同時編譯器在編譯期可以檢查該序列是否為空，字符和數字值是 Rust 中僅有的可以用于判斷是否為空的型別，如下是一個使用字符型別序列的例子：

for i in 'a'..='z' {
    println!("{}",i);
}

a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z

字符

下面的代碼展示了幾個頗具異域風情的字符：

fn main() {
    let c = 'z';
    let z = '?';
    let g = '國';
    let heart_eyed_cat = '??';
}

在 Rust 語言中這些都是字符，Rust 的字符不僅僅是 ASCII，所有的 Unicode 值都可以作為 Rust 字符，包括單個的中文、日文、韓文、emoji 表情符號等等，都是合法的字符型別，Unicode 值的范圍從 U+0000 ~ U+D7FF 和 U+E000 ~ U+10FFFF，

由于 Unicode 都是 4 個位元組編碼，因此字符型別也是占用 4 個位元組：

fn main() {
    let x = '中';
    println!("字符'中'占用了{}位元組的記憶體大小",std::mem::size_of_val(&x));
}

輸出如下:

$ cargo run
   Compiling ...

字符'中'占用了4位元組的記憶體大小

和一些語言不同，Rust 的字符只能用 '' 來表示， "" 是留給字串的

布爾

Rust 中的布爾型別有兩個可能的值：true 和 false，布林值占用記憶體的大小為 1 個位元組：

fn main() {
    let t = true;

    let f: bool = false; // 使用型別標注,顯式指定f的型別

    if f {
        println!("這是段毫無意義的代碼");
    }
}

使用布爾型別的場景主要在于流程控制，例如上述代碼的中的 if 就是其中之一，

復合型別

元組(tuple)用一對 ( ) 包括的一組資料，可以包含不同種類的資料：

let tup: (i32, f64, u8) = (500, 6.4, 1);
// tup.0 等于 500
// tup.1 等于 6.4
// tup.2 等于 1
let (x, y, z) = tup;
// y 等于 6.4

陣列用一對 [ ] 包括的同型別資料，

let a = [1, 2, 3, 4, 5];
// a 是一個長度為 5 的整型陣列

let b = ["January", "February", "March"];
// b 是一個長度為 3 的字串陣列

let c: [i32; 5] = [1, 2, 3, 4, 5];
// c 是一個長度為 5 的 i32 陣列

let d = [3; 5];
// 等同于 let d = [3, 3, 3, 3, 3];

let first = a[0];
let second = a[1];
// 陣列訪問

a[0] = 123; // 錯誤：陣列 a 不可變
let mut a = [1, 2, 3];
a[0] = 4; // 正確

標籤：其他

上一篇：2022-8-11 網路編程（網路通信）

下一篇：C語言呼叫 free 函式釋放記憶體后指標指向及記憶體中的值是否改變的問題