數(shù)據(jù)類型

在Rust中，每個值都有一個明確的數(shù)據(jù)類型，這告訴Rust如何處理這個值。數(shù)據(jù)類型分為兩類子集：標量（scalar）和復合（compound）。

需要記住的是，Rust是一種靜態(tài)類型語言，這意味著在編譯時必須知道所有變量的類型。通常情況下，根據(jù)值及其使用方式，編譯器可以推斷出我們想要的類型。

1.標量類型

在Rust中，標量類型代表單個的簡單數(shù)據(jù)。主要的標量類型包括：

• 整數(shù)類型（Integer Types）：表示整數(shù)值，可以是有符號或無符號的。例如，i32 表示有符號的 32 位整數(shù)，u64 表示無符號的 64 位整數(shù)。

• 浮點數(shù)類型（Floating-Point Types）：表示帶有小數(shù)點的數(shù)值。例如，f64 表示雙精度浮點數(shù)。

• 布爾類型（Boolean Type）：表示邏輯值，只能是 true 或 false。

• 字符類型（Character Type）：表示單個 Unicode 字符，用單引號括起來，例如 'a'。

1. 整數(shù)類型

下面是 Rust 中整數(shù)類型的表格形式：

在Rust中，有符號整數(shù)類型可以表示正數(shù)、負數(shù)和零，而無符號整數(shù)類型只能表示非負數(shù)（即零和正數(shù)），不能表示負數(shù)。

具體來說：

• 有符號整數(shù)類型（Signed Integer Types）：使用一位來表示符號（正或負），其余位表示數(shù)值。例如，對于 i8 類型，8 個位中的第一位表示符號，剩下的 7 位表示數(shù)值范圍。

• 無符號整數(shù)類型（Unsigned Integer Types）：所有位都用來表示數(shù)值，因此只能表示非負數(shù)。例如，對于 u8 類型，所有 8 個位都用來表示數(shù)值范圍。

使用有符號類型或無符號類型取決于你的數(shù)據(jù)表示需求。通常情況下，如果你知道值永遠不會是負數(shù)，可以選擇無符號類型，這樣可以利用更大的范圍來表示正數(shù)。但如果負數(shù)也是可能的，那么需要使用有符號類型。

fn main() {
    // 有符號整數(shù)示例
    let x: i8 = -5;    // 8-bit signed integer
    let y: i16 = -300; // 16-bit signed integer
    let z: i32 = -100000; // 32-bit signed integer

    // 無符號整數(shù)示例
    let a: u8 = 42;     // 8-bit unsigned integer
    let b: u16 = 500;   // 16-bit unsigned integer
    let c: u32 = 100000; // 32-bit unsigned integer

    println!("有符號整數(shù)示例：");
    println!("x: {}", x);
    println!("y: {}", y);
    println!("z: {}", z);

    println!("無符號整數(shù)示例：");
    println!("a: {}", a);
    println!("b: {}", b);
    println!("c: {}", c);


}

在 Rust 中，標準庫提供了一系列的整數(shù)類型，包括有符號和無符號的整數(shù)類型，以及不同位數(shù)的整數(shù)類型，用來滿足不同的需求。

• i8、i16、i32、i64、i128 是有符號整數(shù)類型，分別表示 8 位、16 位、32 位、64 位和 128 位的有符號整數(shù)。
• u8、u16、u32、u64、u128 是無符號整數(shù)類型，分別表示 8 位、16 位、32 位、64 位和 128 位的無符號整數(shù)。

這些整數(shù)類型都是 Rust 編程語言的一部分，用來在代碼中表示不同范圍和精度的整數(shù)值。

無符號整數(shù)類型只能表示非負數(shù)（即零和正數(shù)），不能表示負數(shù)。強行為負數(shù)會進行提示不可以這樣這樣編寫并 且執(zhí)行會報錯

Rust 中各種整數(shù)類型的存儲范圍：

2.浮點數(shù)類型

Rust 有兩個原生的 浮點數(shù)（floating-point numbers）類型，它們是帶小數(shù)點的數(shù)字。Rust 的浮點數(shù)類型是 f32 和 f64，分別占 32 位和 64 位。默認類型是 f64，因為在現(xiàn)代 CPU 中，它與 f32 速度幾乎一樣，不過精度更高。所有的浮點型都是有符號的。

f32 和 f64

• f32：單精度浮點數(shù)，占據(jù) 32 位內(nèi)存空間，提供約 7 位有效數(shù)字的精度。
• f64：雙精度浮點數(shù)，占據(jù) 64 位內(nèi)存空間，提供約 15-16 位有效數(shù)字的精度。

示例代碼

fn main() {
    let x: f32 = 3.14;
    let y: f64 = 3.141592653589793;

    println!("x: {}", x);
    println!("y: {}", y);
}

32 位內(nèi)存空間，提供約 7 位有效數(shù)字的精度。占據(jù) 64 位內(nèi)存空間，提供約 15-16 位有效數(shù)字的精度。

示例代碼中的f32和f64 是標準庫提供的整數(shù)類型

注意事項

• 精度和范圍：使用 f32 和 f64 類型時，需要注意其精度和表示范圍。f32 提供的精度相對較低，但范圍更廣，適用于需要節(jié)省內(nèi)存空間或表示較大范圍的浮點數(shù)。而 f64 提供更高的精度，適用于對精度要求較高的場景。

• 浮點數(shù)運算：在進行浮點數(shù)運算時，需要注意浮點數(shù)的精度問題可能會導致精度損失和舍入誤差。因此，在比較浮點數(shù)時，應該避免直接使用相等性比較，而應該考慮使用誤差范圍內(nèi)的比較。

• 特殊值：浮點數(shù)類型支持特殊值，如正無窮大、負無窮大和 NaN（Not a Number）。這些特殊值可以通過相應的常量來表示，例如 std::f32::INFINITY、std::f32::NEG_INFINITY 和 std::f32::NAN。

fn main() {
    let inf: f32 = std::f32::INFINITY;
    let neg_inf: f32 = std::f32::NEG_INFINITY;
    let nan: f32 = std::f32::NAN;

    println!("Positive Infinity: {}", inf);
    println!("Negative Infinity: {}", neg_inf);
    println!("NaN: {}", nan);
}

在 Rust 中，使用浮點數(shù)類型需要謹慎處理精度和范圍，并且需要了解浮點數(shù)運算可能存在的誤差和特殊值。

3.布爾類型

Rust 中的布爾類型使用 bool 表示，它只有兩個可能的值：true 和 false。與其他大多數(shù)編程語言一樣

fn main() {
    let is_raining = true;
    let is_sunny: bool = false;

    if is_raining {
        println!("Remember to bring an umbrella!");
    } else if is_sunny {
        println!("Don't forget your sunglasses!");
    } else {
        println!("Enjoy the weather!");
    }
}

4.字符類型

Rust 的 char 類型是語言中最原生的字母類型，Rust的 char 類型大小為 4 個字節(jié)，代表 Unicode標量值，這意味著它可以支持中文，日文和韓文字符等非英文字符甚至表情符號和零寬度空格在 Rust 中都是有效的 char 值。

fn main() {
    let heart_emoji = '?';
    let zh_character = '中';
    let smiley = '??';

    println!("Heart Emoji: {}", heart_emoji);
    println!("Chinese Character: {}", zh_character);
    println!("Smiley: {}", smiley);
}

在 Rust 中，要注意用單引號表示字符字面量，而雙引號則用于字符串字面量。Char 類型大小為四個字節(jié)，代表 Unicode 標量值，因此支持各種語言字符、表情符號和零寬度空格。需要留意的是，Unicode 中不存在 “字符” 這一概念，因此人們的直覺可能與 Rust 的 char 不完全匹配。Unicode 標量值范圍廣泛，從 U+0000 到 U+D7FF 和 U+E000 到 U+10FFFF。

2.復合類型

在 Rust 中，復合類型是指能夠?qū)⒍鄠€值組合在一起的類型。這些類型允許你在一個變量中存儲多個值，并以某種方式對它們進行組織和訪問。主要的復合類型包括元組（Tuple）和數(shù)組（Array）。

元組（Tuple）：元組是一個固定大小的有序集合，可以包含不同類型的元素。元組使用圓括號 () 表示，元素之間用逗號 , 分隔。元組的長度是固定的，一旦創(chuàng)建后不能改變。元組允許通過索引訪問其中的元素。

let my_tuple: (i32, f64, char) = (10, 3.14, 'A');

元組的長度是固定的長度是固定的因此 定義長度之后必須要把值填滿，否則會報錯哦

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

    let (x, y, z) = tup;

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

程序首先創(chuàng)建了一個元組并綁定到 tup 變量上。接著使用了 let 和一個模式將 tup 分成了三個不同的變量，x、y 和 z。這叫做 解構(gòu)（destructuring），因為它將一個元組拆成了三個部分。最后，程序打印出了 y 的值，也就是 6.4。

在 Rust 中，你可以使用元組的索引值來訪問元組中的特定元素。元組的索引從 0 開始，即第一個元素的索引是 0，第二個元素的索引是 1，以此類推。以下是一個簡單的示例：

let my_tuple: (i32, f64, char) = (10, 3.14, 'A');

// 訪問第一個元素
let first_element = my_tuple.0;
println!("First element: {}", first_element); // 輸出: First element: 10

// 訪問第二個元素
let second_element = my_tuple.1;
println!("Second element: {}", second_element); // 輸出: Second element: 3.14

// 訪問第三個元素
let third_element = my_tuple.2;
println!("Third element: {}", third_element); // 輸出: Third element: A

不帶任何值的元組有個特殊的名稱，叫做 單元（unit） 元組

數(shù)組（Array）：數(shù)組是一組相同類型的固定大小元素的集合。數(shù)組使用方括號 [] 表示，需要在聲明時指定數(shù)組的長度。數(shù)組的長度也是固定的，一旦創(chuàng)建后不能改變。數(shù)組的所有元素都具有相同的類型。

let my_array: [i32; 5] = [1, 2, 3, 4, 5];

在 Rust 中，你可以使用索引值來訪問數(shù)組中的特定元素。數(shù)組的索引同樣從 0 開始，即第一個元素的索引是 0，第二個元素的索引是 1，以此類推。以下是一個簡單的示例：

let my_array: [i32; 5] = [1, 2, 3, 4, 5];

// 訪問第一個元素
let first_element = my_array[0];
println!("First element: {}", first_element); // 輸出: First element: 1

// 訪問第三個元素
let third_element = my_array[2];
println!("Third element: {}", third_element); // 輸出: Third element: 3

數(shù)組的長度也是固定的 因此定義長度之后必須要把值填滿，否則會報錯哦

整數(shù)類型技術細節(jié)

在 Rust 中，整數(shù)溢出是指當一個整數(shù)的值超出了其所能表示的范圍時發(fā)生的情況。Rust 提供了多種方式來處理整數(shù)溢出，包括檢查溢出、panic on overflow 和使用 Wrapping 模式。下面我將詳細介紹這些方式，并提供相應的示例代碼。

1. 檢查溢出（Checking Overflow）

在 Rust 中，可以使用 checked_add、checked_sub、checked_mul 等方法來檢查整數(shù)加法、減法、乘法是否會導致溢出。這些方法返回一個 Option 類型，如果計算結(jié)果在整數(shù)類型能表示的范圍內(nèi)，則返回 Some，否則返回 None。

示例代碼：

fn main() {
    let x: i32 = 2147483647;
    let y = x.checked_add(1); // 檢查加法溢出
    match y {
        Some(result) => println!("Result: {}", result),
        None => println!("Overflow occurred!"),
    }
}

2. 溢出時 panic（Panic on Overflow）

如果希望在發(fā)生溢出時立即停止程序并產(chǎn)生 panic，可以使用 overflowing_add、overflowing_sub、overflowing_mul 等方法。這些方法返回一個元組，其中第一個元素是計算結(jié)果，第二個元素是一個布爾值，表示是否發(fā)生了溢出。

示例代碼：

fn main() {
    let x: i32 = 2147483647;
    let (result, overflow) = x.overflowing_add(1); // 檢查加法溢出
    if overflow {
        panic!("Overflow occurred!");
    } else {
        println!("Result: {}", result);
    }
}

3. 使用 Wrapping 模式（Wrapping Behavior）

如果希望在發(fā)生溢出時按照模運算的方式處理，可以使用 wrapping_add、wrapping_sub、wrapping_mul 等方法。這些方法會對溢出的部分進行截斷，并返回一個包裝過的結(jié)果。

示例代碼：

fn main() {
    let x: i32 = 2147483647;
    let result = x.wrapping_add(1); // 檢查加法溢出
    println!("Result: {}", result); // 結(jié)果會是 -2147483648
}

到此這篇關于Rust語言數(shù)據(jù)類型的具體使用的文章就介紹到這了,更多相關Rust語言數(shù)據(jù)類型內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！ 

最新評論