數(shù)據(jù)類(lèi)型

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

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

1.標(biāo)量類(lèi)型

在Rust中，標(biāo)量類(lèi)型代表單個(gè)的簡(jiǎn)單數(shù)據(jù)。主要的標(biāo)量類(lèi)型包括：

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

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

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

• 字符類(lèi)型（Character Type）：表示單個(gè) Unicode 字符，用單引號(hào)括起來(lái)，例如 'a'。

1. 整數(shù)類(lèi)型

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

在Rust中，有符號(hào)整數(shù)類(lèi)型可以表示正數(shù)、負(fù)數(shù)和零，而無(wú)符號(hào)整數(shù)類(lèi)型只能表示非負(fù)數(shù)（即零和正數(shù)），不能表示負(fù)數(shù)。

具體來(lái)說(shuō)：

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

• 無(wú)符號(hào)整數(shù)類(lèi)型（Unsigned Integer Types）：所有位都用來(lái)表示數(shù)值，因此只能表示非負(fù)數(shù)。例如，對(duì)于 u8 類(lèi)型，所有 8 個(gè)位都用來(lái)表示數(shù)值范圍。

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

fn main() {
    // 有符號(hào)整數(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

    // 無(wú)符號(hào)整數(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!("有符號(hào)整數(shù)示例：");
    println!("x: {}", x);
    println!("y: {}", y);
    println!("z: {}", z);

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


}

在 Rust 中，標(biāo)準(zhǔn)庫(kù)提供了一系列的整數(shù)類(lèi)型，包括有符號(hào)和無(wú)符號(hào)的整數(shù)類(lèi)型，以及不同位數(shù)的整數(shù)類(lèi)型，用來(lái)滿(mǎn)足不同的需求。

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

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

無(wú)符號(hào)整數(shù)類(lèi)型只能表示非負(fù)數(shù)（即零和正數(shù)），不能表示負(fù)數(shù)。強(qiáng)行為負(fù)數(shù)會(huì)進(jìn)行提示不可以這樣這樣編寫(xiě)并 且執(zhí)行會(huì)報(bào)錯(cuò)

Rust 中各種整數(shù)類(lèi)型的存儲(chǔ)范圍：

2.浮點(diǎn)數(shù)類(lèi)型

Rust 有兩個(gè)原生的 浮點(diǎn)數(shù)（floating-point numbers）類(lèi)型，它們是帶小數(shù)點(diǎn)的數(shù)字。Rust 的浮點(diǎn)數(shù)類(lèi)型是 f32 和 f64，分別占 32 位和 64 位。默認(rèn)類(lèi)型是 f64，因?yàn)樵诂F(xiàn)代 CPU 中，它與 f32 速度幾乎一樣，不過(guò)精度更高。所有的浮點(diǎn)型都是有符號(hào)的。

f32 和 f64

• f32：?jiǎn)尉雀↑c(diǎn)數(shù)，占據(jù) 32 位內(nèi)存空間，提供約 7 位有效數(shù)字的精度。
• f64：雙精度浮點(diǎn)數(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 是標(biāo)準(zhǔn)庫(kù)提供的整數(shù)類(lèi)型

注意事項(xiàng)

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

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

• 特殊值：浮點(diǎn)數(shù)類(lèi)型支持特殊值，如正無(wú)窮大、負(fù)無(wú)窮大和 NaN（Not a Number）。這些特殊值可以通過(guò)相應(yīng)的常量來(lái)表示，例如 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 中，使用浮點(diǎn)數(shù)類(lèi)型需要謹(jǐn)慎處理精度和范圍，并且需要了解浮點(diǎn)數(shù)運(yùn)算可能存在的誤差和特殊值。

3.布爾類(lèi)型

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

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.字符類(lèi)型

Rust 的 char 類(lèi)型是語(yǔ)言中最原生的字母類(lèi)型，Rust的 char 類(lèi)型大小為 4 個(gè)字節(jié)，代表 Unicode標(biāo)量值，這意味著它可以支持中文，日文和韓文字符等非英文字符甚至表情符號(hào)和零寬度空格在 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 中，要注意用單引號(hào)表示字符字面量，而雙引號(hào)則用于字符串字面量。Char 類(lèi)型大小為四個(gè)字節(jié)，代表 Unicode 標(biāo)量值，因此支持各種語(yǔ)言字符、表情符號(hào)和零寬度空格。需要留意的是，Unicode 中不存在 “字符” 這一概念，因此人們的直覺(jué)可能與 Rust 的 char 不完全匹配。Unicode 標(biāo)量值范圍廣泛，從 U+0000 到 U+D7FF 和 U+E000 到 U+10FFFF。

2.復(fù)合類(lèi)型

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

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

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

元組的長(zhǎng)度是固定的長(zhǎng)度是固定的因此 定義長(zhǎng)度之后必須要把值填滿(mǎn)，否則會(huì)報(bào)錯(cuò)哦

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

    let (x, y, z) = tup;

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

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

在 Rust 中，你可以使用元組的索引值來(lái)訪(fǎng)問(wèn)元組中的特定元素。元組的索引從 0 開(kāi)始，即第一個(gè)元素的索引是 0，第二個(gè)元素的索引是 1，以此類(lèi)推。以下是一個(gè)簡(jiǎn)單的示例：

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

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

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

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

不帶任何值的元組有個(gè)特殊的名稱(chēng)，叫做 單元（unit） 元組

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

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

在 Rust 中，你可以使用索引值來(lái)訪(fǎng)問(wèn)數(shù)組中的特定元素。數(shù)組的索引同樣從 0 開(kāi)始，即第一個(gè)元素的索引是 0，第二個(gè)元素的索引是 1，以此類(lèi)推。以下是一個(gè)簡(jiǎn)單的示例：

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

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

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

數(shù)組的長(zhǎng)度也是固定的 因此定義長(zhǎng)度之后必須要把值填滿(mǎn)，否則會(huì)報(bào)錯(cuò)哦

整數(shù)類(lèi)型技術(shù)細(xì)節(jié)

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

1. 檢查溢出（Checking Overflow）

在 Rust 中，可以使用 checked_add、checked_sub、checked_mul 等方法來(lái)檢查整數(shù)加法、減法、乘法是否會(huì)導(dǎo)致溢出。這些方法返回一個(gè) Option 類(lèi)型，如果計(jì)算結(jié)果在整數(shù)類(lèi)型能表示的范圍內(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. 溢出時(shí) panic（Panic on Overflow）

如果希望在發(fā)生溢出時(shí)立即停止程序并產(chǎn)生 panic，可以使用 overflowing_add、overflowing_sub、overflowing_mul 等方法。這些方法返回一個(gè)元組，其中第一個(gè)元素是計(jì)算結(jié)果，第二個(gè)元素是一個(gè)布爾值，表示是否發(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ā)生溢出時(shí)按照模運(yùn)算的方式處理，可以使用 wrapping_add、wrapping_sub、wrapping_mul 等方法。這些方法會(huì)對(duì)溢出的部分進(jìn)行截?cái)啵⒎祷匾粋€(gè)包裝過(guò)的結(jié)果。

示例代碼：

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

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