《Rust编程入门》4.2 数据类型与类型推断

4.2 数据类型与类型推断

Rust 是一门强类型语言，每个值都必须有一个明确的类型。Rust 的静态类型系统在编译期对代码进行严格检查，从而避免运行时错误。同时，Rust 也支持类型推断，大多数情况下可以省略显式标注类型。本节将介绍 Rust 的基本数据类型、复合类型及其类型推断机制。

4.2.1 标量类型

标量（scalar）类型表示一个单一的值，Rust 中的标量类型有以下四种：

1. 整型（Integer）

Rust 提供了有符号（i）和无符号（u）的整型，支持多种位宽。

类型 描述 范围
i8 8 位有符号整数 -128 到 127
u8 8 位无符号整数 0 到 255
i16 16 位有符号整数 -32,768 到 32,767
u16 16 位无符号整数 0 到 65,535
i32 32 位有符号整数 -2,147,483,648 到 2,147,483,647
u32 32 位无符号整数 0 到 4,294,967,295
i64 64 位有符号整数 -2⁶³ 到 2⁶³-1
u64 64 位无符号整数 0 到 2⁶⁴-1
isize 有符号整数，平台相关 根据架构（32 位或 64 位）
usize 无符号整数，平台相关 根据架构（32 位或 64 位）

示例：整型使用

1
2
3
4
5

fn main() {
    let x: i32 = 42; // 显式声明类型
    let y = 255u8;   // 使用后缀标注类型
    println!("x = {}, y = {}", x, y);
}

2. 浮点型（Floating-Point）

Rust 提供两种浮点类型：

  • f32: 32 位单精度浮点数
  • f64: 64 位双精度浮点数（默认类型）

示例：浮点数

1
2
3
4
5

fn main() {
    let pi: f64 = 3.141592653589793;
    let e = 2.71828f32; // 使用后缀标注类型
    println!("pi = {}, e = {}", pi, e);
}

3. 布尔型（Boolean）

布尔类型表示真或假，类型名为 bool。

示例：布尔值

1
2
3
4
5

fn main() {
    let is_rust_fun = true;
    let is_too_hard: bool = false;
    println!("Rust 好玩吗？{}", is_rust_fun);
}

4. 字符型（Character）

Rust 的字符类型为 char，表示一个 Unicode 字符（4 个字节）。

示例：字符

1
2
3
4
5

fn main() {
    let c = '😊';
    let letter: char = 'R';
    println!("字符: {}, 字母: {}", c, letter);
}

4.2.2 复合类型

复合类型可以将多个值组合在一起，主要包括元组（Tuple）和数组（Array）。

1. 元组（Tuple）

元组可以包含不同类型的多个值。

示例：元组

1
2
3
4
5

fn main() {
    let tuple: (i32, f64, char) = (42, 3.14, 'R');
    let (x, y, z) = tuple; // 解构
    println!("元组: x = {}, y = {}, z = {}", x, y, z);
}

2. 数组（Array）

数组是固定大小的同类型值的集合。数组的长度在编译期固定。

示例：数组

1
2
3
4
5

fn main() {
    let numbers: [i32; 3] = [1, 2, 3];
    let repeated = [0; 5]; // 创建一个全为 0 的数组，长度为 5
    println!("第一个元素: {}, 长度: {}", numbers[0], numbers.len());
}

4.2.3 类型推断

Rust 的编译器拥有强大的类型推断能力，可以根据上下文自动推导变量类型。通常情况下，开发者可以省略显式的类型标注。

示例：类型推断

1
2
3
4
5
6

fn main() {
    let x = 42;      // 推断为 i32
    let y = 3.14;    // 推断为 f64
    let z = 'R';     // 推断为 char
    println!("x = {}, y = {}, z = {}", x, y, z);
}

4.2.4 类型转换

Rust 不支持隐式类型转换，需要显式地进行类型转换。

示例：类型转换

1
2
3
4
5

fn main() {
    let x: i32 = 10;
    let y: f64 = x as f64 + 2.5; // 显式转换
    println!("结果: {}", y);
}

4.2.5 小结

Rust 的数据类型系统结合了静态类型检查和灵活的类型推断能力，确保代码安全性和高效性。掌握标量类型、复合类型及类型转换机制，是深入学习 Rust 编程的基础。

在下一节中，我们将探讨 Rust 中的运算符和表达式，了解如何在程序中执行各种操作。