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的位数与目标机器的指针大小一致。
示例：
rust
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, 取余结果: 01.2 浮点数类型（Floating-Point）
Rust 提供了两种浮点数类型：f32 和 f64，分别表示 32 位和 64 位浮点数。
特性：
- 默认类型是
f64。 - 浮点数遵循 IEEE 754 标准。
示例：
rust
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.15526131.3 布尔类型（Boolean）
布尔类型只有两个值：true 和 false。
特性：
- 用于条件判断和逻辑运算。
示例：
rust
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 有趣且不难学吗？ true1.4 字符类型（Character）
字符类型 char 表示单个 Unicode 标量值，占用 4 个字节。
特性：
- 使用单引号定义（如
'a'）。 - 支持 Unicode，可以表示中文、表情符号等。
示例：
rust
fn main() {
let letter: char = 'R';
let emoji: char = '🚀';
println!("字母: {}, 表情符号: {}", letter, emoji);
}输出：
字母: R, 表情符号: 🚀2. Compound 类型
Compound 类型可以将多个值组合成一个类型，包括元组（Tuple）和数组（Array）。
2.1 元组（Tuple）
元组是将多个不同类型的值组合在一起的复合类型。
特性：
- 长度固定，声明后无法改变。
- 使用点号（
.）和索引访问元素。
示例：
rust
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
元组的第一个元素: 5002.2 数组（Array）
数组是将多个相同类型的值组合在一起的复合类型。
特性：
- 长度固定，声明后无法改变。
- 使用索引访问元素。
示例：
rust
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 类型的用法：
rust
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 的类型系统都能满足多样化的需求。