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, 取余结果: 0

1.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.1552613

1.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 有趣且不难学吗？ true

1.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
元组的第一个元素: 500

2.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 的类型系统都能满足多样化的需求。