Rust 基础之常用语法

Rust 基础语法：
变量与数据类型：展示了可变与不可变变量、类型标注以及各种基本数据类型
复合类型：包括元组和数组的定义与使用
控制流：演示了 if 表达式、loop 循环、while 循环和 for 循环
函数：包含了简单函数、返回多个值的函数等
所有权与借用：Rust 的核心特性，展示了所有权转移、不可变借用和可变借用
结构体：定义了结构体并为其实现方法
枚举与模式匹配：展示了枚举的定义、方法实现和模式匹配的使用
错误处理：通过 Result 类型和自定义错误类型演示了 Rust 的错误处理机制
rust 复制代码
// 主函数，程序入口点
fn main() {
    // 1. 变量与数据类型
    println!("\n=== 变量与数据类型 ===");
    
    // 不可变变量（默认）
    let x = 5;
    println!("x 的值: {}", x);
    
    // 可变变量
    let mut y = 10;
    println!("y 的初始值: {}", y);
    y = 20;
    println!("y 修改后的值: {}", y);
    
    // 显式类型标注
    let z: f64 = 3.14159;
    println!("z 的值: {}", z);
    
    // 布尔类型
    let is_rust_fun: bool = true;
    println!("Rust 有趣吗? {}", is_rust_fun);
    
    // 字符类型（Unicode）
    let heart: char = '❤️';
    println!("爱心符号: {}", heart);
    
    // 2. 复合类型
    println!("\n=== 复合类型 ===");
    
    // 元组
    let tuple: (i32, &str, f64) = (42, "答案", 3.14);
    println!("元组第一个元素: {}", tuple.0);
    println!("元组第二个元素: {}", tuple.1);
    
    // 解构元组
    let (a, b, c) = tuple;
    println!("解构后 - a: {}, b: {}, c: {}", a, b, c);
    
    // 数组（固定大小）
    let numbers: [i32; 5] = [1, 2, 3, 4, 5];
    println!("数组第三个元素: {}", numbers[2]);
    println!("数组长度: {}", numbers.len());
    
    // 3. 控制流
    println!("\n=== 控制流 ===");
    
    // if 表达式
    let age = 18;
    if age >= 18 {
        println!("已成年");
    } else if age >= 13 {
        println!("青少年");
    } else {
        println!("儿童");
    }
    
    // 循环
    let mut count = 0;
    loop {
        count += 1;
        if count == 3 {
            println!("循环执行了 3 次，退出循环");
            break;
        }
    }
    
    // while 循环
    let mut n = 5;
    while n > 0 {
        println!("倒计时: {}", n);
        n -= 1;
    }
    
    // for 循环
    println!("数组元素:");
    for num in numbers.iter() {
        println!("{}", num);
    }
    
    // 范围循环
    println!("1 到 5:");
    for i in 1..=5 {
        println!("{}", i);
    }
    
    // 4. 函数
    println!("\n=== 函数 ===");
    
    let sum = add(3, 5);
    println!("3 + 5 = {}", sum);
    
    let (product, difference) = multiply_and_subtract(4, 2);
    println!("4 × 2 = {}, 4 - 2 = {}", product, difference);
    
    // 5. 所有权与借用
    println!("\n=== 所有权与借用 ===");
    
    let s1 = String::from("Rust");
    let s2 = take_ownership(s1);
    // println!("s1: {}", s1);  // 错误：s1 已经失去所有权
    
    let s3 = String::from("编程");
    let len = calculate_length(&s3);
    println!("'{}' 的长度是: {}", s3, len);  // s3 仍然有效
    
    let mut s4 = String::from("可变");
    change_string(&mut s4);
    println!("修改后的字符串: {}", s4);
    
    // 6. 结构体
    println!("\n=== 结构体 ===");
    
    let mut person = Person {
        name: String::from("张三"),
        age: 30,
        is_student: false,
    };
    println!("姓名: {}", person.name);
    println!("年龄: {}", person.age);
    
    person.age = 31;
    println!("更新后的年龄: {}", person.age);
    
    let employee = Employee::new(String::from("李四"), 35, String::from("工程师"));
    employee.print_info();
    
    // 7. 枚举与模式匹配
    println!("\n=== 枚举与模式匹配 ===");
    
    let some_number = Option::Some(5);
    let some_string = Option::Some(String::from("Hello"));
    let none_value: Option<i32> = Option::None;
    
    print_option(some_number);
    print_option(some_string);
    print_option(none_value);
    
    let shape = Shape::Circle(5.0);
    println!("形状面积: {}", shape.area());
    
    // 8. 错误处理
    println!("\n=== 错误处理 ===");
    
    match divide(10, 2) {
        Ok(result) => println!("10 ÷ 2 = {}", result),
        Err(e) => println!("错误: {}", e),
    }
    
    match divide(5, 0) {
        Ok(result) => println!("5 ÷ 0 = {}", result),
        Err(e) => println!("错误: {}", e),
    }
    
    // 使用 ? 运算符简化错误处理
    let result = safe_division(8, 4);
    println!("使用 ? 运算符: {:?}", result);
}

// 简单加法函数
fn add(a: i32, b: i32) -> i32 {
    a + b  // Rust 函数最后一行表达式的结果会自动返回，无需 return 关键字
}

// 返回多个值的函数
fn multiply_and_subtract(a: i32, b: i32) -> (i32, i32) {
    (a * b, a - b)
}

// 展示所有权转移
fn take_ownership(s: String) -> String {
    println!("接收的字符串: {}", s);
    s  // 返回字符串，将所有权转移回调用者
}

// 展示不可变借用
fn calculate_length(s: &String) -> usize {
    s.len()
}

// 展示可变借用
fn change_string(s: &mut String) {
    s.push_str(" 字符串");
}

// 定义结构体
struct Person {
    name: String,
    age: u32,
    is_student: bool,
}

// 结构体示例 2
struct Employee {
    name: String,
    age: u32,
    position: String,
}

// 为结构体实现方法
impl Employee {
    // 关联函数（类似静态方法）
    fn new(name: String, age: u32, position: String) -> Self {
        Employee {
            name,
            age,
            position,
        }
    }
    
    // 实例方法
    fn print_info(&self) {
        println!("员工信息 - 姓名: {}, 年龄: {}, 职位: {}", self.name, self.age, self.position);
    }
}

// 定义枚举
enum Shape {
    Circle(f64),  // 圆，存储半径
    Rectangle(f64, f64),  // 矩形，存储宽和高
    Square(f64),  // 正方形，存储边长
}

// 为枚举实现方法
impl Shape {
    fn area(&self) -> f64 {
        match self {
            Shape::Circle(radius) => 3.14159 * radius * radius,
            Shape::Rectangle(width, height) => width * height,
            Shape::Square(side) => side * side,
        }
    }
}

// 模式匹配示例
fn print_option<T: std::fmt::Display>(option: Option<T>) {
    match option {
        Some(value) => println!("有值: {}", value),
        None => println!("无值"),
    }
}

// 错误处理示例：定义错误类型
#[derive(Debug)]
enum DivisionError {
    DivisionByZero,
}

// 为错误类型实现 Display trait
impl std::fmt::Display for DivisionError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            DivisionError::DivisionByZero => write!(f, "除数不能为零"),
        }
    }
}

// 除法函数，可能返回错误
fn divide(a: i32, b: i32) -> Result<i32, DivisionError> {
    if b == 0 {
        Err(DivisionError::DivisionByZero)
    } else {
        Ok(a / b)
    }
}

// 使用 ? 运算符的函数
fn safe_division(a: i32, b: i32) -> Result<i32, DivisionError> {
    let result = divide(a, b)?;  // 如果有错误，直接返回错误
    Ok(result)
}

```