Rust 数据类型详解：Scalar 与 Compound 类型
Rust 是一门强类型语言，其类型系统设计严谨且功能强大。Rust 的数据类型可以分为两大类：Scalar（标量）类型 和 Compound（复合）类型。本文将详细介绍这些类型及其特性，并通过示例展示它们的用法。
1. Scalar 类型
Scalar 类型表示单个值，包括整数、浮点数、布尔值和字符。
1.1 整数类型（Integer）
Rust 提供了多种整数类型，分为有符号（i 开头）和无符号（u 开头）两类。例如：
- 有符号：
i8,i16,i32,i64,i128,isize - 无符号：
u8,u16,u32,u64,u128,usize
特性：
- 默认类型是
i32。 isize和usize的位数与目标机器的指针大小一致。
示例：
fn main() {let a: i32 = 10; // 有符号整数let b = 20; // 默认推断为有符号整数 i32// 整数运算let sum = a + b; // 加法let diff = a - b; // 减法let product = a * b; // 乘法let quotient = b / a; // 除法let remainder = b % a; // 取余println!("加法结果: {}, 减法结果: {}, 乘法结果: {}, 除法结果: {}, 取余结果: {}", sum, diff, product, quotient, remainder);
}
}
输出：
加法结果: 30, 减法结果: -10, 乘法结果: 200, 除法结果: 2, 取余结果: 0
1.2 浮点数类型（Floating-Point）
Rust 提供了两种浮点数类型：f32 和 f64，分别表示 32 位和 64 位浮点数。
特性：
- 默认类型是
f64。 - 浮点数遵循 IEEE 754 标准。
示例：
fn main() {let x: f32 = 3.14; // 32 位浮点数let y: f64 = 2.718; // 64 位浮点数// 浮点数运算let sum = x + y as f32; // 加法（注意类型转换）let diff = x - y as f32; // 减法let product = x * y as f32; // 乘法let quotient = x / y as f32; // 除法println!("加法结果: {}, 减法结果: {}, 乘法结果: {}, 除法结果: {}", sum, diff, product, quotient);
}
输出：
加法结果: 5.858, 减法结果: 0.42200017, 乘法结果: 8.53452, 除法结果: 1.1552613
1.3 布尔类型（Boolean）
布尔类型只有两个值：true 和 false。
特性：
- 用于条件判断和逻辑运算。
示例：
fn main() {let is_rust_fun: bool = true;let is_learning_hard: bool = false;// 逻辑运算let result = is_rust_fun && !is_learning_hard; // 与运算和取反println!("Rust 有趣且不难学吗？ {}", result);
}
输出：
Rust 有趣且不难学吗？ true
1.4 字符类型（Character）
字符类型 char 表示单个 Unicode 标量值，占用 4 个字节。
特性：
- 使用单引号定义（如
'a'）。 - 支持 Unicode，可以表示中文、表情符号等。
示例：
fn main() {let letter: char = 'R';let emoji: char = '🚀';println!("字母: {}, 表情符号: {}", letter, emoji);
}
输出：
字母: R, 表情符号: 🚀
2. Compound 类型
Compound 类型可以将多个值组合成一个类型，包括元组（Tuple）和数组（Array）。
2.1 元组（Tuple）
元组是将多个不同类型的值组合在一起的复合类型。
特性：
- 长度固定，声明后无法改变。
- 使用点号（
.）和索引访问元素。
示例：
fn main() {let tup: (i32, f64, char) = (500, 6.4, 'Z');// 解构元组let (x, y, z) = tup;println!("x: {}, y: {}, z: {}", x, y, z);// 直接访问元组元素println!("元组的第一个元素: {}", tup.0);
}
输出：
x: 500, y: 6.4, z: Z
元组的第一个元素: 500
2.2 数组（Array）
数组是将多个相同类型的值组合在一起的复合类型。
特性：
- 长度固定，声明后无法改变。
- 使用索引访问元素。
示例：
fn main() {let arr: [i32; 5] = [1, 2, 3, 4, 5];// 访问数组元素println!("数组的第一个元素: {}", arr[0]);println!("数组的第二个元素: {}", arr[1]);// 遍历数组for i in arr.iter() {println!("{}", i);}
}
输出：
数组的第一个元素: 1
数组的第二个元素: 2
1
2
3
4
5
综合示例
以下是一个综合示例，展示了 Scalar 和 Compound 类型的用法：
fn main() {// Scalar 类型let int_var: i32 = 42;let float_var: f64 = 3.14;let bool_var: bool = true;let char_var: char = 'R';// Compound 类型let tup: (i32, f64, char) = (int_var, float_var, char_var);let arr: [i32; 3] = [1, 2, 3];// 打印 Scalar 类型println!("整数: {}", int_var);println!("浮点数: {}", float_var);println!("布尔值: {}", bool_var);println!("字符: {}", char_var);// 打印 Compound 类型println!("元组: ({}, {}, {})", tup.0, tup.1, tup.2);println!("数组: [{}, {}, {}]", arr[0], arr[1], arr[2]);// 数字操作let sum = int_var + (float_var as i32); // 加法let product = int_var * 2; // 乘法let quotient = float_var / 2.0; // 除法let remainder = int_var % 10; // 取余println!("加法结果: {}, 乘法结果: {}, 除法结果: {}, 取余结果: {}", sum, product, quotient, remainder);
}
输出：
整数: 42
浮点数: 3.14
布尔值: true
字符: R
元组: (42, 3.14, R)
数组: [1, 2, 3]
加法结果: 45, 乘法结果: 84, 除法结果: 1.57, 取余结果: 2
总结
Rust 的数据类型系统设计严谨，分为 Scalar 和 Compound 类型：
- Scalar 类型：包括整数、浮点数、布尔值和字符，适合表示单个值。
- Compound 类型：包括元组和数组，适合组合多个值。
通过合理使用这些类型，可以编写出高效且安全的 Rust 程序。无论是系统编程还是应用开发，Rust 的类型系统都能满足多样化的需求。
