課題摘要:
在 Rust 中，字面量、運算符和表達式是構建程序的基礎組件，它們共同構成了 Rust 語言的核心語法。本文介紹Rust中的字面量、運算符和表達式。

關鍵詞：字面量、運算符、表達式

---

一、字面量

在 Rust 中，字面量（Literals）是指直接在代碼中表示的值，它們是程序中最基本的表達形式。字面量可以是數字、字符、字符串、布爾值等。以下是對 Rust 中字面量的詳細解析：

1. 字面量的分類

Rust 中的字面量可以分為以下幾類：

1.1 整數字面量

整數字面量可以表示整數類型（如 i32、u32、i64 等）。它們可以有以下幾種形式：

• 十進制：直接寫數字，如 42。
• 十六進制：以 0x 開頭，如 0x2A（等同于十進制的 42）。
• 八進制：以 0o 開頭，如 0o52（等同于十進制的 42）。
• 二進制：以 0b 開頭，如 0b101010（等同于十進制的 42）。
• 下劃線分隔：可以在數字中使用下劃線 _ 來分隔數字，提高可讀性，如 1_000_000。

示例：

let decimal = 42;
let hex = 0x2A;
let octal = 0o52;
let binary = 0b101010;
let large_number = 1_000_000;

1.2 浮點數字面量

浮點數字面量用于表示浮點數，可以是 f32 或 f64 類型。它們可以有以下幾種形式：

• 十進制表示：直接寫數字和小數點，如 3.14。
• 科學計數法：使用 e 或 E 表示指數部分，如 1.23e4（等同于 12300.0）。
• 類型后綴：可以顯式指定類型后綴，如 1.23f32 或 4.56f64。

示例：

let float = 3.14;
let scientific = 1.23e4;
let f32_value = 4.56f32;
let f64_value = 7.89f64;

1.3 字符字面量

字符字面量用于表示單個字符，用單引號 ' 包裹。它可以表示：

• 普通字符：如 'a'。
• Unicode 字符：如 '中'。
• 轉義字符：如 '\n'（換行符）、'\t'（制表符）、'\\'（反斜杠）等。
• Unicode 轉義：使用 \u{} 表示 Unicode 碼點，如 '\u{4E2D}'（等同于 '中'）。

示例：

let letter = 'a';
let chinese_char = '中';
let newline = '\n';
let unicode_escape = '\u{4E2D}';

1.4 字符串字面量

字符串字面量用于表示字符串，用雙引號 " 包裹。它可以包含：

• 普通字符：如 "Hello, world!"。

• 轉義字符：如 "\n"（換行符）、"\t"（制表符）、"\\"（反斜杠）等。

• 原始字符串：使用 r#""# 包裹，可以包含任意字符，包括換行符和雙引號，而無需轉義。例如：

  let raw_string = r#"C:\Users\Alice\Documents"#;
  

示例：

let greeting = "Hello, world!";
let multiline_string = "This is a\nmultiline string.";
let raw_string = r#"C:\Users\Alice\Documents"#;

1.5 布爾字面量

布爾字面量只有兩個值：true 和 false。

示例：

let is_active = true;
let is_disabled = false;

1.6 字節數組字面量

字節數組字面量用于表示字節數組，用 b"" 包裹。它可以包含：

• 普通字符：如 b"Hello"。
• 轉義字符：如 b"\n"（換行符）、b"\t"（制表符）、b"\\"（反斜杠）等。

示例：

let bytes = b"Hello";

2. 字面量的類型推斷

Rust 是一種強類型語言，但在某些情況下，字面量的類型可以由編譯器推斷。例如：

• 如果上下文明確指定了類型，編譯器會根據上下文推斷字面量的類型。
• 如果沒有明確指定類型，編譯器會使用默認類型：
  • 整數默認為 i32。
  • 浮點數默認為 f64。

示例：

let x = 42; // 默認類型為 i32
let y = 3.14; // 默認類型為 f64let z: i64 = 123; // 顯式指定類型為 i64
let w: f32 = 4.56; // 顯式指定類型為 f32

3. 字面量的用途

字面量在 Rust 中的用途非常廣泛，主要用于以下場景：

• 初始化變量：為變量賦初始值。
• 函數參數：作為函數的參數傳遞。
• 數組和元組的元素：作為數組或元組的元素。
• 條件表達式：在 if、while 等條件表達式中使用。

4. 字面量的限制

• 類型必須明確：雖然編譯器可以推斷某些字面量的類型，但在某些情況下，必須顯式指定類型。
• 轉義字符的使用：在字符串和字符字面量中，特殊字符需要使用轉義序列。
• 原始字符串的限制：原始字符串不能使用轉義字符，但可以通過 r#""# 包裹來包含任意字符。

字面量總結

字面量是 Rust 中最基本的數據表示形式，它用于直接在代碼中表示值。Rust 支持多種類型的字面量，包括整數、浮點數、字符、字符串、布爾值和字節數組。通過合理使用字面量，可以簡化代碼的編寫，并提高代碼的可讀性。

二、運算符

在 Rust 中，運算符用于執行各種操作，包括算術運算、邏輯運算、比較運算等。Rust 提供了豐富的運算符，涵蓋了幾乎所有常見的操作。以下是對 Rust 中運算符的詳細解析：

1. 算術運算符

算術運算符用于執行基本的數學運算。

運算符	描述	示例	結果
+	加法	let a = 1 + 2;	a = 3
-	減法	let b = 5 - 3;	b = 2
*	乘法	let c = 4 * 3;	c = 12
/	除法	let d = 10 / 2;	d = 5
%	取模（余數）	let e = 10 % 3;	e = 1

2. 邏輯運算符

邏輯運算符用于執行布爾邏輯運算。

運算符	描述	示例	結果
&&	邏輯與	let a = true && false;	a = false
`		`	邏輯或
!	邏輯非	let c = !true;	c = false

3. 比較運算符

比較運算符用于比較兩個值，并返回布爾值。

運算符	描述	示例	結果
==	等于	let a = 1 == 2;	a = false
!=	不等于	let b = 1 != 2;	b = true
>	大于	let c = 2 > 1;	c = true
<	小于	let d = 1 < 2;	d = true
>=	大于等于	let e = 2 >= 2;	e = true
<=	小于等于	let f = 1 <= 2;	f = true

4. 位運算符

位運算符用于對整數的二進制位進行操作。

運算符	描述	示例	結果
&	位與	let a = 5 & 3;	a = 1
`	`	位或	`let b = 5
^	位異或	let c = 5 ^ 3;	c = 6
!	位非	let d = !5;	d = -6
<<	左移	let e = 5 << 1;	e = 10
>>	右移	let f = 5 >> 1;	f = 2

5. 賦值運算符

賦值運算符用于將值賦給變量。

運算符	描述	示例	結果
=	簡單賦值	let a = 5;	a = 5
+=	加法賦值	let mut a = 5; a += 3;	a = 8
-=	減法賦值	let mut b = 5; b -= 3;	b = 2
*=	乘法賦值	let mut c = 5; c *= 3;	c = 15
/=	除法賦值	let mut d = 10; d /= 2;	d = 5
%=	取模賦值	let mut e = 10; e %= 3;	e = 1
&=	位與賦值	let mut a = 5; a &= 3;	a = 1
`	=`	位或賦值	`let mut b = 5; b
^=	位異或賦值	let mut c = 5; c ^= 3;	c = 6
<<=	左移賦值	let mut e = 5; e <<= 1;	e = 10
>>=	右移賦值	let mut f = 5; f >>= 1;	f = 2

6. 范圍運算符

范圍運算符用于創建范圍。

運算符	描述	示例	結果
..	范圍（不包括上界）	for i in 0..5 { ... }	i = 0, 1, 2, 3, 4
..=	范圍（包括上界）	for i in 0..=5 { ... }	i = 0, 1, 2, 3, 4, 5

7. 條件運算符

Rust 還提供了一個三元條件運算符，用于根據條件選擇值。

運算符	描述	示例	結果
?	條件運算符	let a = if condition { x } else { y };	根據條件返回 x 或 y

8. 運算符重載

Rust 允許通過實現特定的特質（traits）來重載運算符。例如，可以通過實現 std::ops::Add 特質來重載 + 運算符。

use std::ops::Add;struct Point {x: i32,y: i32,
}impl Add for Point {type Output = Point;fn add(self, other: Point) -> Point {Point {x: self.x + other.x,y: self.y + other.y,}}
}fn main() {let p1 = Point { x: 1, y: 2 };let p2 = Point { x: 3, y: 4 };let p3 = p1 + p2; // 使用重載的 + 運算符println!("p3: ({}, {})", p3.x, p3.y); // 輸出：p3: (4, 6)
}

注意事項

• 優先級：Rust 的運算符有優先級，例如乘法和除法的優先級高于加法和減法。可以通過括號改變優先級。
• 短路邏輯：邏輯與（&&）和邏輯或（||）運算符具有短路行為，即如果第一個條件已經決定了結果，第二個條件不會被計算。
• 溢出：整數運算可能會導致溢出。在調試模式下，Rust 會檢查溢出并報錯；在發布模式下，溢出行為是未定義的。

通過合理使用這些運算符，可以編寫出高效且可讀性強的 Rust 代碼。

三、表達式

在 Rust 中，表達式（Expression）是程序中執行某些操作并產生值的語法構造。與語句（Statement）不同，表達式總是返回一個值，而語句則不返回值。理解表達式是掌握 Rust 編程的基礎。以下是對 Rust 中表達式的詳細解析。

1. 表達式的定義

表達式是 Rust 程序的基本構建塊，它可以執行操作并產生一個值。表達式可以非常簡單，如一個字面量或變量，也可以是復雜的，包含多個操作符和子表達式。

2. 表達式的類型

Rust 中的表達式可以分為以下幾類：

字面量表達式

字面量是直接表示值的表達式，例如數字、字符串或布爾值。

let x = 42; // 整數字面量
let y = "Hello"; // 字符串字面量
let z = true; // 布爾字面量

變量表達式

變量表達式是通過變量名引用變量的值。

let a = 10;
let b = a; // 使用變量 a 的值

運算符表達式

運算符表達式是通過運算符對值進行操作的表達式。

let sum = 1 + 2; // 加法運算符
let product = 3 * 4; // 乘法運算符
let is_equal = 5 == 5; // 比較運算符

函數調用表達式

函數調用表達式是通過函數名和參數列表調用函數的表達式。

fn add(a: i32, b: i32) -> i32 {a + b
}let result = add(3, 4); // 調用函數

方法調用表達式

方法調用表達式是通過對象調用其方法的表達式。

let mut vec = Vec::new();
vec.push(1); // 調用 Vec 的 push 方法

條件表達式

條件表達式是根據條件選擇不同值的表達式。Rust 中的 if 表達式是一個典型的條件表達式。

let number = 5;
let is_positive = if number > 0 { true } else { false };

循環表達式

循環表達式是通過循環語句執行重復操作的表達式。Rust 中的 loop、while 和 for 都是循環表達式。

let mut counter = 0;
let result = loop {counter += 1;if counter == 10 {break counter * 2;}
};
println!("Result: {}", result); // 輸出：Result: 20

塊表達式

塊表達式是通過花括號 {} 包裹的一組語句和表達式。塊表達式返回其最后一個表達式的值。

let x = {let y = 3;y + 1
};
println!("x: {}", x); // 輸出：x: 4

3. 表達式的值

每個表達式都有一個值，這個值可以被賦值給變量，也可以作為其他表達式的一部分。例如：

let x = 5 + 3; // 表達式 5 + 3 的值是 8
let y = {let z = 10;z + 2 // 塊表達式的值是 z + 2 的結果，即 12
};

4. 表達式的優先級

Rust 中的表達式遵循一定的優先級規則，這些規則決定了表達式中各個部分的計算順序。例如，乘法和除法的優先級高于加法和減法。

let result = 5 + 3 * 2; // 先計算 3 * 2，再計算 5 + 6

如果需要改變優先級，可以使用括號明確指定計算順序：

let result = (5 + 3) * 2; // 先計算 5 + 3，再計算 8 * 2

5. 表達式與語句的區別

在 Rust 中，表達式和語句是不同的概念：

• 表達式：總是返回一個值。
• 語句：不返回值，通常用于執行某些操作，如變量聲明或函數調用。

例如，以下是一個語句：

let x = 5; // 這是一個語句，它聲明了一個變量 x

而以下是一個表達式：

let y = { 5 }; // 這是一個塊表達式，它的值是 5

6. 表達式的應用場景

表達式在 Rust 中的應用非常廣泛，以下是一些常見的應用場景：

函數返回值

函數的返回值是一個表達式的結果。例如：

fn add(a: i32, b: i32) -> i32 {a + b // 表達式
}

條件分支

if 和 match 表達式用于根據條件選擇不同的值。例如：

let number = 5;
let is_positive = if number > 0 { true } else { false };let message = match number {0 => "zero",1 => "one",_ => "other",
};

循環控制

loop、while 和 for 表達式用于執行重復操作。例如：

let mut counter = 0;
let result = loop {counter += 1;if counter == 10 {break counter * 2;}
};

7. 示例代碼

以下是一個完整的示例代碼，展示了 Rust 中表達式的多種用法：

fn main() {// 字面量表達式let x = 42;// 變量表達式let y = x;// 運算符表達式let sum = x + y;// 函數調用表達式let product = multiply(x, y);// 條件表達式let is_positive = if sum > 0 { true } else { false };// 塊表達式let z = {let temp = 10;temp + 2};// 循環表達式let mut counter = 0;let result = loop {counter += 1;if counter == 10 {break counter * 2;}};println!("x: {}", x);println!("y: {}", y);println!("sum: {}", sum);println!("product: {}", product);println!("is_positive: {}", is_positive);println!("z: {}", z);println!("result: {}", result);
}fn multiply(a: i32, b: i32) -> i32 {a * b
}

表達式總結

Rust 中的表達式是程序的核心組成部分，它們用于執行操作并產生值。表達式可以非常簡單，也可以非常復雜，涵蓋了字面量、變量、運算符、函數調用、條件分支、循環控制等多種形式。通過合理使用表達式，可以編寫出高效且可讀性強的 Rust 代碼。

四、綜合示例

以下是一個綜合示例代碼，展示了 Rust 中字面量、運算符及表達式的用法：

fn main() {// 字面量的使用// 整數字面量let decimal = 42;let hex = 0x2A;let octal = 0o52;let binary = 0b101010;let large_number = 1_000_000;// 浮點數字面量let float = 3.14;let scientific = 1.23e4;let f32_value = 4.56f32;let f64_value = 7.89f64;// 字符字面量let letter = 'a';let chinese_char = '中';let newline = '\n';let unicode_escape = '\u{4E2D}';// 字符串字面量let greeting = "Hello, world!";let multiline_string = "This is a\nmultiline string.";let raw_string = r#"C:\Users\Alice\Documents"#;// 布爾字面量let is_active = true;let is_disabled = false;// 字節數組字面量let bytes = b"Hello";// 輸出字面量的值println!("整數字面量：decimal = {}, hex = {}, octal = {}, binary = {}, large_number = {}", decimal, hex, octal, binary, large_number);println!("浮點數字面量：float = {}, scientific = {}, f32_value = {}, f64_value = {}", float, scientific, f32_value, f64_value);println!("字符字面量：letter = {}, chinese_char = {}, newline = {:?}, unicode_escape = {}", letter, chinese_char, newline, unicode_escape);println!("字符串字面量：greeting = {}, multiline_string = {}", greeting, multiline_string);println!("原始字符串：raw_string = {}", raw_string);println!("布爾字面量：is_active = {}, is_disabled = {}", is_active, is_disabled);println!("字節數組字面量：bytes = {:?}", bytes);// 運算符的使用// 算術運算符let sum = 1 + 2;let difference = 5 - 3;let product = 4 * 3;let quotient = 10 / 2;let remainder = 10 % 3;// 邏輯運算符let and_result = true && false;let or_result = true || false;let not_result = !true;// 比較運算符let equal = 1 == 2;let not_equal = 1 != 2;let greater_than = 2 > 1;let less_than = 1 < 2;let greater_than_or_equal = 2 >= 2;let less_than_or_equal = 1 <= 2;// 位運算符let bitwise_and = 5 & 3;let bitwise_or = 5 | 3;let bitwise_xor = 5 ^ 3;let bitwise_not = !5;let left_shift = 5 << 1;let right_shift = 5 >> 1;// 賦值運算符let mut a = 5;a += 3;let mut b = 5;b -= 3;let mut c = 5;c *= 3;let mut d = 10;d /= 2;let mut e = 10;e %= 3;// 輸出運算符的結果println!("算術運算符：sum = {}, difference = {}, product = {}, quotient = {}, remainder = {}", sum, difference, product, quotient, remainder);println!("邏輯運算符：and_result = {}, or_result = {}, not_result = {}", and_result, or_result, not_result);println!("比較運算符：equal = {}, not_equal = {}, greater_than = {}, less_than = {}, greater_than_or_equal = {}, less_than_or_equal = {}", equal, not_equal, greater_than, less_than, greater_than_or_equal, less_than_or_equal);println!("位運算符：bitwise_and = {}, bitwise_or = {}, bitwise_xor = {}, bitwise_not = {}, left_shift = {}, right_shift = {}", bitwise_and, bitwise_or, bitwise_xor, bitwise_not, left_shift, right_shift);println!("賦值運算符：a = {}, b = {}, c = {}, d = {}, e = {}", a, b, c, d, e);// 表達式的使用// 字面量表達式let x = 42;// 變量表達式let y = x;// 運算符表達式let sum = x + y;// 函數調用表達式let product = multiply(x, y);// 條件表達式let is_positive = if sum > 0 { true } else { false };// 塊表達式let z = {let temp = 10;temp + 2};// 循環表達式let mut counter = 0;let result = loop {counter += 1;if counter == 10 {break counter * 2;}};// 輸出表達式的結果println!("字面量表達式：x = {}", x);println!("變量表達式：y = {}", y);println!("運算符表達式：sum = {}", sum);println!("函數調用表達式：product = {}", product);println!("條件表達式：is_positive = {}", is_positive);println!("塊表達式：z = {}", z);println!("循環表達式：result = {}", result);
}// 定義一個簡單的函數
fn multiply(a: i32, b: i32) -> i32 {a * b
}

運行結果

整數字面量：decimal = 42, hex = 42, octal = 42, binary = 42, large_number = 1000000
浮點數字面量：float = 3.14, scientific = 12300, f32_value = 4.56, f64_value = 7.89
字符字面量：letter = a, chinese_char = 中, newline = '\n', unicode_escape = 中
字符串字面量：greeting = Hello, world!, multiline_string = This is a
multiline string.
原始字符串：raw_string = C:\Users\Alice\Documents
布爾字面量：is_active = true, is_disabled = false
字節數組字面量：bytes = [72, 101, 108, 108, 111]
算術運算符：sum = 3, difference = 2, product = 12, quotient = 5, remainder = 1
邏輯運算符：and_result = false, or_result = true, not_result = false
比較運算符：equal = false, not_equal = true, greater_than = true, less_than = true, greater_than_or_equal = true, less_than_or_equal = true
位運算符：bitwise_and = 1, bitwise_or = 7, bitwise_xor = 6, bitwise_not = -6, left_shift = 10, right_shift = 2
賦值運算符：a = 8, b = 2, c = 15, d = 5, e = 1
字面量表達式：x = 42
變量表達式：y = 42
運算符表達式：sum = 84
函數調用表達式：product = 1764
條件表達式：is_positive = true
塊表達式：z = 12
循環表達式：result = 20進程已結束，退出代碼為 0

示例代碼說明

1. 字面量的使用：

   • 展示了各種類型的字面量（整數、浮點數、字符、字符串、布爾值、字節數組）的定義和輸出。
   • 包括不同進制的整數字面量（十進制、十六進制、八進制、二進制）和字符串的轉義字符。

2. 運算符的使用：

   • 展示了算術運算符、邏輯運算符、比較運算符、位運算符和賦值運算符的用法。
   • 每個運算符的結果都被打印出來，便于觀察。

3. 表達式的使用：

   • 展示了字面量表達式、變量表達式、運算符表達式、函數調用表達式、條件表達式、塊表達式和循環表達式的用法。
   • 每個表達式的結果都被打印出來，展示了表達式的多樣性和靈活性。

通過這個示例代碼，可以全面了解 Rust 中字面量、運算符和表達式的用法。

總結

在 Rust 中，字面量、運算符和表達式是構建程序的基礎組件，它們共同構成了 Rust 語言的核心語法。

字面量（Literals）

字面量是直接表示值的語法構造，它們是表達式的最基本形式。Rust 支持多種類型的字面量，包括：

• 整數字面量：如 42、0xFF（十六進制）、0b1010（二進制）。
• 浮點數字面量：如 3.14、2.0f64（顯式指定類型）。
• 字符字面量：如 'a'、'中'（UTF-8 編碼）。
• 字符串字面量：如 "Hello"，存儲為 UTF-8 編碼的字符串。
• 布爾字面量：true 和 false。
• 數組和元組字面量：如 [1, 2, 3]（數組）、(1, "a")（元組）。

字面量是不可變的，它們的值在編譯時就已經確定。

運算符（Operators）

運算符是用于對字面量或變量進行操作的符號。Rust 提供了多種運算符，包括：

• 算術運算符：+、-、*、/、%。
• 邏輯運算符：&&（邏輯與）、||（邏輯或）、!（邏輯非）。
• 比較運算符：==、!=、>、<、>=、<=。
• 位運算符：&、|、^、!、<<、>>。
• 賦值運算符：=、+=、-=、*=、/=、%= 等。
• 范圍運算符：..（不包括上界）、..=（包括上界）。

運算符用于組合字面量和變量，形成更復雜的表達式。

表達式（Expressions）

表達式是由字面量、變量、運算符和函數調用等組成的語法構造，它們可以執行操作并返回一個值。表達式是 Rust 程序的基本構建塊，例如：

• 簡單表達式：1 + 2、x * y。
• 函數調用表達式：add(3, 4)。
• 條件表達式：if x > 0 { 1 } else { -1 }。
• 塊表達式：{ let y = 3; y + 1 }。
• 循環表達式：loop { break 42; }。

表達式可以嵌套，形成復雜的邏輯結構。Rust 的表達式遵循優先級規則，可以通過括號明確指定計算順序。

總之，字面量是表達式的最基本形式，表示具體的值；運算符用于對字面量和變量進行操作；表達式則是由字面量、變量和運算符組合而成的語法構造，用于執行操作并產生值。它們共同構成了 Rust 程序的基礎，是編寫 Rust 代碼的核心語法元素。