目录

  1. 什么是 Rust 数据类型
  2. 为什么要学习数据类型
  3. 标量类型
  4. 复合类型
  5. 类型推导与显式声明
  6. 类型转换
  7. 代码示例
  8. 参考资料与出站链接

什么是 Rust 数据类型

Rust 数据类型定义了变量可以存储的值的种类和操作方式。Rust 是静态强类型语言，编译时必须知道所有变量的类型。它分为标量类型（单一值）和复合类型（多个值组合）。

为什么要学习数据类型

  • 类型安全：确保程序行为符合预期。
  • 性能优化：选择合适类型减少资源浪费。
  • 代码清晰：显式类型提高可读性。
  • 所有权理解：类型影响内存管理。

标量类型

标量类型表示单个值，包括以下四种：

  1. 整数 (Integer)：
  • 有符号：i8, i16, i32, i64, i128。
  • 无符号：u8, u16, u32, u64, u128。
  • 默认：i32。
  1. 浮点数 (Floating-point)：
  • f32, f64（默认）。
  1. 布尔 (Boolean)：
  • bool：true 或 false。
  1. 字符 (Character)：
  • char：Unicode 标量值（如 'A'、'中'），4 字节。

复合类型

复合类型将多个值组合成一个类型，包括：

  1. 元组 (Tuple)：
  • 固定长度，异构类型，用 ( ) 定义。
  • 访问：通过 .0, .1 等索引。
  1. 数组 (Array)：
  • 固定长度，同构类型，用 [ ] 定义。
  • 访问：通过 [index]。
  1. 字符串 (String)（技术上是复合类型的一部分）：
  • String：动态、可变，堆分配。
  • &str：静态、不可变，字符串切片。

类型推导与显式声明

  • 类型推导：Rust 编译器根据上下文推断类型。
  • 显式声明：使用 :类型 指定。
let x = 42;       // 推导为 i32
let y: i64 = 42;  // 显式声明

类型转换

Rust 不支持隐式转换，需使用 as 或特定方法：

  • as：基本类型转换。
  • into/try_into：更安全的转换（需导入 std::convert::TryInto）。
let a: i32 = 42;
let b: f64 = a as f64;  // 整数转浮点

代码示例

标量与复合类型

fn main() {
    // 标量类型
    let num: i32 = -10;
    let pi: f64 = 3.14159;
    let flag: bool = true;
    let ch: char = '锈';

    println!("整数: {}, 浮点: {}, 布尔: {}, 字符: {}", num, pi, flag, ch);

    // 复合类型
    let tup: (i32, f64, char) = (1, 2.5, 'a');
    let arr: [i32; 3] = [10, 20, 30];
    let s: String = String::from("Rust");

    println!("元组: ({}, {}, {}), 数组: {:?}, 字符串: {}", tup.0, tup.1, tup.2, arr, s);
}

运行结果：

整数: -10, 浮点: 3.14159, 布尔: true, 字符: 锈
元组: (1, 2.5, a), 数组: [10, 20, 30], 字符串: Rust

类型转换

fn main() {
    let x: i32 = 255;
    let y: u8 = x as u8;  // 可能溢出
    println!("i32: {} -> u8: {}", x, y);

    let f: f32 = 3.14;
    let i: i32 = f as i32;  // 截断小数
    println!("f32: {} -> i32: {}", f, i);
}

运行结果：

i32: 255 -> u8: 255
f32: 3.14 -> i32: 3

参考资料与出站链接

  1. 官方文档：
  1. 学习资源：
  1. 社区支持：