Rust 基础数据类型与变量机制

整数溢出这块，Debug 和 Release 的行为不一样。Debug 下会检查，出了问题直接 panic；Release 里通常会按两补数环绕处理。实际写代码时，别把'能跑'当成'没问题'，溢出最好显式处理。

// 使用 checked_* 方法，溢出时返回 None
let x: u8 = 255;
match x.checked_add(1) {
    Some(y) => println!("255 + 1 = {}", y),
    None => println!("255 + 1 发生溢出"), // 会执行这条
}
// 使用 saturating_* 方法，溢出时取最大值/最小值
let y: u8 = 255;
let z = y.saturating_add(1); // z = 255
// 使用 wrapping_* 方法，强制两补数环绕
let w: u8 = 255;
let v = w.wrapping_add(1); // v = 0

2.1.2 浮点数类型

Rust 只有两种浮点数：f32 和 f64。默认一般是 f64。它们都遵循 IEEE-754 标准，只是精度不同。

• f32：32 位单精度，约 6-7 位小数
• f64：64 位双精度，约 15-17 位小数

// 十进制小数
let a = 3.14; // f64（默认）
let b: f32 = 2.718; // 显式类型注解
// 科学计数法
let c = 1e5; // f64，100000.0
let d: f32 = 2.5e-3; // 0.0025

浮点数最常见的问题不是语法，而是精度。0.1 + 0.2 这类看上去很简单的表达式，结果不一定等于你直觉里的 0.3。

let x = 0.1 + 0.2;
println!("0.1 + 0.2 = {}", x); // 输出 0.30000000000000004
println!("x == 0.3? {}", x == 0.3); // 输出 false
// 解决方法：比较差值是否小于一个极小值（epsilon）
fn float_equals(a: f64, b: f64) -> bool {
    (a - b).abs() < 1e-9
}
println!("x == 0.3? {}", float_equals(x, 0.3)); // 输出 true

2.1.3 布尔类型

Rust 的布尔类型只有 bool，值只能是 true 或 false。它占 1 字节，主要是为了对齐，不是因为逻辑上需要这么多空间。

let is_true = true;
let is_false: bool = false; // 布尔类型常用于条件判断
if is_true {
    println!("这是真的");
} else {
    println!("这是假的");
}
// 布尔类型可以转换为整数
let true_as_u8 = is_true as u8; // 1
let false_as_u8 = is_false as u8; // 0

2.1.4 字符类型

Rust 的 char 是 Unicode 标量值，不是 C 里那种单字节字符。它占 4 字节，能表示中文、日文、表情符号这些内容。

let a = 'A'; // 英文大写字母，ASCII 码 65
let b: char = '中'; // 中文，Unicode 值 U+4E2D
let c = '😀'; // 表情符号，Unicode 值 U+1F600
// 字符类型可以转换为整数
let a_as_u32 = a as u32; // 65
println!("'A'的 Unicode 值是 U+{:X}", a_as_u32); // 输出 U+41

2.2 复合类型

2.2.1 元组类型

元组是固定长度、允许不同类型混在一起的组合。长度一旦定了，就不能再变。

// 声明元组
let t1: (i32, f64, bool) = (10, 3.14, true);
let t2 = ("hello", 'R', 2024); // 编译器自动推断类型
// 访问元组元素
println!("t1 的第 0 个元素：{}", t1.0); // 10
println!("t1 的第 1 个元素：{}", t1.1); // 3.14
println!("t1 的第 2 个元素：{}", t1.2); // true
// 解构赋值
let (x, y, z) = t2;
println!("x = {}, y = {}, z = {}", x, y, z); // x = hello, y = R, z = 2024
// 单元素元组（必须加逗号）
let t3 = (5,); // 类型是 (i32,)
let t4 = (5); // 这不是元组，而是整数 5
// 空元组（单元类型，值只有一个 ()）
let t5 = (); // 类型是 ()，常用于表示无返回值的函数

元组很适合当函数返回值，尤其是'顺手带回两个结果'的时候。

fn calculate_rectangle(width: u32, height: u32) -> (u32, u32) {
    let area = width * height;
    let perimeter = (width + height) * 2;
    (area, perimeter)
}

fn main() {
    let (area, perimeter) = calculate_rectangle(10, 5);
    println!("面积：{}，周长：{}", area, perimeter);
}

2.2.2 数组类型

数组是固定长度、同一种类型的组合，存放在栈上。它适合长度已知、数据量不大的场景。

// 声明数组
let a: [i32; 3] = [1, 2, 3]; // 类型注解：[元素类型; 长度]
let b = [10, 20, 30]; // 编译器自动推断类型
let c = [5; 4]; // 初始化：每个元素都是 5，长度为 4
// 访问数组元素
println!("a 的第 0 个元素：{}", a[0]); // 1
println!("a 的第 2 个元素：{}", a[2]); // 3
println!("c 的第 1 个元素：{}", c[1]); // 5
// 获取数组长度
println!("a 的长度：{}", a.len()); // 3
// 数组遍历
for element in a.iter() {
    println!("{}", element); // 输出 1、2、3
}
// 可变数组
let mut d = [1, 2, 3];
d[0] = 10; // 修改第 0 个元素
println!("d 的第 0 个元素：{}", d[0]); // 10

数组越界在 Rust 里不会悄悄吞掉，运行时会直接 panic。这个设计很硬，但对排查问题省事。

let a = [1, 2, 3];
println!("a 的第 3 个元素：{}", a[3]); // 运行期崩溃：index out of bounds: the len is 3 but the index is 3

2.2.3 切片类型

切片可以理解成数组或 Vec 的一段视图，它自己不存数据，只带着指针和长度。用切片的时候，真正的数据还是在原数组或原 Vec 里。

• 指向数组/Vec 的指针（*const T 或 *mut T）
• 切片长度（usize）

切片的类型是 &[T] 或 &mut [T]。

// 不可变数组切片
let a = [1, 2, 3, 4, 5];
let slice1 = &a[1..3]; // 从索引 1 到索引 3（不包含 3），元素是 [2, 3]
let slice2 = &a[..2]; // 从开头到索引 2（不包含 2），元素是 [1, 2]
let slice3 = &a[3..]; // 从索引 3 到结尾，元素是 [4, 5]
let slice4 = &a[..]; // 整个数组，元素是 [1,2,3,4,5]
println!("slice1 的第 0 个元素：{}", slice1[0]); // 2
println!("slice1 的长度：{}", slice1.len()); // 2
// 可变数组切片
let mut b = [1, 2, 3, 4, 5];
let mut_slice = &mut b[1..3];
mut_slice[0] = 20; // 修改切片的第 0 个元素，也就是原数组的第 1 个元素
println!("原数组 b：{:?}", b); // 输出 [1,20,3,4,5]
// Vec 的切片
let mut vec = vec![10, 20, 30, 40, 50];
let vec_slice = &vec[2..4];
println!("Vec 切片：{:?}", vec_slice); // [30,40]

2.3 字符串类型

Rust 里字符串常见的就两种：&str 和 String。初学时最好先把它们分开记，不然后面所有权一上来就容易乱。

• &str 是字符串切片，通常指向字符串字面量或别的字符串的一部分
• String 是可变字符串，数据放在堆上

// 字符串字面量（&str）
let s1: &str = "Hello, Rust!"; // 存储在静态内存上
let s2 = "这是中文"; // 编译器自动推断类型为 &str
// String 类型的创建
let s3 = String::new(); // 创建空字符串
let s4 = String::from(s1); // 从 &str 创建 String
let s5 = String::from("动态字符串"); // 直接创建
// 字符串连接
let s6 = s4 + " " + s5.as_str(); // 注意：s4 被转移所有权，s5 需要.as_str() 转换为 &str
println!("s6：{}", s6);
// 不可变字符串连接
let s7 = format!("{} {} {}", s1, s5, 2024);
println!("s7：{}", s7);
// 字符串切片（按字节索引，Rust 的字符串是 UTF-8 编码）
let s8 = "Rust 语言开发";
println!("s8 的第 0-3 字节：{}", &s8[0..3]); // Rust
// println!("s8 的第 4-5 字节：{}", &s8[4..6]); // 编译期崩溃：byte index 4 is not a char boundary
for c in s8.chars() {
    println!("{}", c); // 输出 R、u、s、t、语、言、开、发
}

2.4 变量系统

2.4.1 变量声明

Rust 里声明变量用 let。默认情况下，变量是不可变的，这一点和很多语言正好相反。

// 简单声明（编译器自动推断类型）
let x = 10;
let y = "hello";
// 显式类型注解
let z: u8 = 255;
let w: String = String::from("Rust");

2.4.2 变量的可变性

如果要改值，就在声明时加 mut。Rust 这里的态度很明确：能不改就别改。

let mut x = 10;
x = 20;
println!("x：{}", x); // 输出 20
let mut s = String::from("hello");
s.push_str(", Rust!");
println!("s：{}", s); // 输出 hello, Rust!

2.4.3 变量的作用域

变量从声明开始生效，到所在代码块结束为止。出了作用域，变量就不可用了。

fn main() {
    let x = 10; // x 的作用域开始
    {
        let y = 20; // y 的作用域开始
        println!("x + y = {}", x + y); // 30，x 可以访问，y 可以访问
    }
    // y 的作用域结束
    // println!("y = {}", y); // 编译错误：y 未声明
    println!("x = {}", x); // 10，x 的作用域未结束
}
// x 的作用域结束

2.4.4 Shadowing

Shadowing 是同名新变量把旧变量遮住了。它和 mut 最大的区别是：Shadowing 不是原地修改，而是重新绑定。

// 同一作用域内的 Shadowing
let x = 10;
let x = x + 5; // 新变量 x 隐藏旧变量 x，类型仍然是 i32，值是 15
println!("x：{}", x); // 15
// 嵌套作用域内的 Shadowing
let y = 20;
{
    let y = "hello"; // 新变量 y 隐藏旧变量 y，类型是 &str
    println!("内部 y：{}", y); // hello
}
println!("外部 y：{}", y); // 20，旧变量 y 重新可见
// Shadowing 与类型转换结合
let z = "123";
let z = z.parse::<i32>().unwrap(); // 新变量 z 隐藏旧变量 z，类型是 i32，值是 123
println!("z：{}", z); // 123

2.5 类型转换

Rust 对类型转换管得比较严，隐式转换很少。大多数时候都要你明确写出来。

2.5.1 as 关键字转换

as 适合基础类型之间的转换，写起来直接，但也正因为直接，风险也更容易被忽略。

// 整数类型之间的转换
let a: i32 = 100;
let b: u8 = a as u8; // 100
let c: i8 = 255 as i8; // -1（两补数环绕）
// 整数转浮点数
let d: i32 = 5;
let e: f64 = d as f64; // 5.0
// 浮点数转整数（截断）
let f: f64 = 3.14;
let g: i32 = f as i32; // 3
// 字符转整数
let h: char = 'A';
let i: u32 = h as u32; // 65

as 有几个边界要记住：

• 不能拿它做非基础类型之间的转换，比如 String 和 &str
• 浮点转整数会直接截断小数部分
• 大整数转小整数可能会发生环绕，结果不一定符合直觉

2.5.2 From / Into

From 和 Into 更偏向'可预期'的转换方式。只要类型实现了 From，通常就能顺带拿到 Into。

// String 和 &str 之间的转换
let s1: &str = "hello";
let s2: String = String::from(s1); // 使用 From
let s3: String = s1.into(); // 使用 Into
// 整数类型之间的安全转换
use std::convert::TryFrom;
use std::convert::TryInto;
let a: i32 = 100;
let b: Result<u8, std::num::TryFromIntError> = u8::try_from(a);
match b {
    Ok(x) => println!("a 转换为 u8：{}", x),
    Err(e) => println!("转换失败：{}", e),
}
let c: Result<u8, std::num::TryFromIntError> = a.try_into();
// 自定义类型的转换
struct Person {
    name: String,
    age: u32,
}
struct PersonInfo {
    name: &'static str,
    age: u32,
}
impl From<PersonInfo> for Person {
    fn from(info: PersonInfo) -> Self {
        Person {
            name: String::from(info.name),
            age: info.age,
        }
    }
}
let info = PersonInfo { name: "张三", age: 25 };
let person: Person = info.into();
println!("姓名：{}，年龄：{}", person.name, person.age);

真实案例应用

3.1 计算多种几何图形的面积

这个例子主要是把枚举、模式匹配和基础数值类型串起来。场景很简单：不同图形的参数不同，但面积计算都返回 f64。

#[derive(Debug)]
enum Shape {
    Circle(f64), // 半径
    Rectangle(f64, f64), // 长和宽
    Triangle(f64, f64), // 底和高
}

impl Shape {
    fn area(&self) -> f64 {
        match self {
            Shape::Circle(radius) => std::f64::consts::PI * radius * radius,
            Shape::Rectangle(width, height) => width * height,
            Shape::Triangle(base, height) => base * height / 2.0,
        }
    }
}

fn main() {
    let circle = Shape::Circle(5.0);
    let rectangle = Shape::Rectangle(10.0, 5.0);
    let triangle = Shape::Triangle(6.0, 4.0);
    println!("圆形面积：{:.2}", circle.area()); // 78.54
    println!("矩形面积：{:.2}", rectangle.area()); // 50.00
    println!("三角形面积：{:.2}", triangle.area()); // 12.00
}

3.2 处理用户输入的成绩数据

这里用数组、循环和切片把一个小统计程序跑起来。它不算优雅，但处理输入、校验、统计这几个动作都在里面了，适合拿来理解基础类型怎么配合。

use std::io;

fn main() {
    let mut scores = [0; 50];
    let mut count = 0;
    println!("请输入学生成绩（输入 -1 结束）：");
    loop {
        let mut input = String::new();
        io::stdin().read_line(&mut input).expect("读取输入失败");
        let score: i32 = match input.trim().parse() {
            Ok(num) => num,
            Err(_) => {
                println!("请输入有效的整数");
                continue;
            }
        };
        if score == -1 {
            break;
        }
        if score < 0 || score > 100 {
            println!("成绩必须在 0-100 之间");
            continue;
        }
        if count >= 50 {
            println!("最多只能输入 50 个成绩");
            break;
        }
        scores[count] = score;
        count += 1;
    }
    if count == 0 {
        println!("没有输入成绩");
        return;
    }
    let sum: i32 = scores[0..count].iter().sum();
    let average = sum as f64 / count as f64;
    let max_score = scores[0..count].iter().max().unwrap();
    let min_score = scores[0..count].iter().min().unwrap();
    let mut grade_counts = [0; 5]; // 0-59, 60-69, 70-79, 80-89, 90-100
    for &score in scores[0..count].iter() {
        match score {
            0..=59 => grade_counts[0] += 1,
            60..=69 => grade_counts[1] += 1,
            70..=79 => grade_counts[2] += 1,
            80..=89 => grade_counts[3] += 1,
            90..=100 => grade_counts[4] += 1,
            _ => (),
        }
    }
    println!("成绩统计结果：");
    println!("----------------------");
    println!("学生人数：{}", count);
    println!("平均分：{:.2}", average);
    println!("最高分：{}", max_score);
    println!("最低分：{}", min_score);
    println!("----------------------");
    println!("成绩分布：");
    println!("0-59 分：{}人", grade_counts[0]);
    println!("60-69 分：{}人", grade_counts[1]);
    println!("70-79 分：{}人", grade_counts[2]);
    println!("80-89 分：{}人", grade_counts[3]);
    println!("90-100 分：{}人", grade_counts[4]);
}

3.3 解析 CSV 格式的产品数据

这个例子展示了字符串切分、结构体、Vec 和过滤逻辑怎么一起工作。CSV 这里是简化版，只按逗号分隔，不处理转义和引号。

#[derive(Debug)]
struct Product {
    name: String,
    price: f64,
    stock: u32,
}

fn parse_product_csv(line: &str) -> Option<Product> {
    let fields: Vec<&str> = line.split(',').collect();
    if fields.len() != 3 {
        return None;
    }
    let name = fields[0].trim().to_string();
    let price: f64 = match fields[1].trim().parse() {
        Ok(num) => num,
        Err(_) => return None,
    };
    let stock: u32 = match fields[2].trim().parse() {
        Ok(num) => num,
        Err(_) => return None,
    };
    Some(Product { name, price, stock })
}

fn main() {
    let csv_data = " 苹果，5.99, 100\n香蕉，2.49, 200\n橙子，3.99, 150\n葡萄，9.99, 50\n西瓜，12.99, 30\n错误数据，abc, 10 ";
    let mut products = Vec::new();
    for line in csv_data.lines() {
        let trimmed_line = line.trim();
        if trimmed_line.is_empty() {
            continue;
        }
        match parse_product_csv(trimmed_line) {
            Some(product) => products.push(product),
            None => println!("忽略无效行：{}", trimmed_line),
        }
    }
    let filtered_products: Vec<&Product> = products
        .iter()
        .filter(|p| p.price >= 5.0 && p.price <= 10.0)
        .collect();
    println!("价格在 5-10 元之间的产品：");
    println!("----------------------------------");
    println!("产品名称\t价格\t库存");
    println!("----------------------------------");
    for product in filtered_products {
        println!("{}\t{:.2}\t{}", product.name, product.price, product.stock);
    }
}

常见问题和处理方式

4.1 整数溢出导致的崩溃

Debug 模式下，整数溢出会触发 panic。处理上还是那几个办法：checked_*、saturating_*、wrapping_*。别指望默认行为替你兜底。

4.2 浮点数精度导致的逻辑错误

0.1 + 0.2 != 0.3 不是 Rust 独有的问题，是浮点表示方式的老毛病。比较时通常改成差值阈值判断。

4.3 数组越界访问导致的崩溃

越界访问会 panic。更稳妥的方式是先检查范围，或者直接用 get() 拿 Option。

let a = [1, 2, 3];
if let Some(element) = a.get(3) {
    println!("{}", element);
} else {
    println!("索引无效");
}

4.4 类型不匹配导致的编译错误

如果参数类型对不上，Rust 不会帮你猜。通常就是三步：看类型注解、显式转换、必要时用 dbg!() 看值。

let x = 10;
dbg!(x); // 输出 [src/main.rs:2:5] x = 10
let y = x as u8;
dbg!(y); // 输出 [src/main.rs:4:5] y = 10

收尾

基础类型这块，学完以后最重要的不是背表，而是知道什么时候该用哪种类型。整数要盯住溢出，浮点数要避开精确相等比较，字符串别把 &str 和 String 搞混，数组和切片也别把'视图'和'数据'混为一谈。Rust 的规则多，但大多数都不是为了添麻烦，而是把问题尽量提前到编译期。

下一篇会接着讲函数和流程控制，重点放在参数、返回值、if、match 和几种循环写法上。