Rust 编程学习笔记

1. 变量与常量

Rust 使用 let 声明变量，使用 const 声明常量。变量默认不可变。

let age = 30;         // 不可变变量
let mut name = "Alice"; // 可变变量
const PI: f64 = 3.1415; // 常量，必须显式定义类型

注意事项：变量不可变是 Rust 的默认行为，使用 mut 关键字声明可变变量。

2. 数据类型

Rust 是强类型语言，支持基础数据类型：整数、浮点数、布尔值、字符等。

let height: f64 = 1.75;
let is_student: bool = true;

易错点：类型推断一般可省略，但在复杂类型或不同平台的代码中可能需要显式定义。

3. 条件语句

Rust 使用 if 和 else 语句进行条件判断，条件必须返回布尔值。

let status = if age > 18 { "Adult" } else { "Minor" };

注意事项：if 语句可以返回值，且条件必须是布尔类型。

4. 函数

使用 fn 定义函数，Rust 函数返回值使用箭头 -> 表示。

fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

易错点：函数的返回值不使用 return 时，返回的表达式不应加分号。

5. 所有权与借用

Rust 使用所有权机制管理内存，避免了传统的垃圾回收。

fn main() {
    let s1 = String::from("hello");
    let s2 = &s1;       // 借用
    println!("{}", s2);
}

注意事项：默认借用是不可变的，使用 &mut 进行可变借用。

6. 结构体与枚举

结构体用于定义自定义数据类型，枚举用于定义可能的状态。

struct Person {
    name: String,
    age: u32,
}

enum Status {
    Active,
    Inactive,
}

注意事项：结构体字段默认不可变，枚举有助于表达多种状态。

7. 模式匹配

Rust 的 match 表达式用于模式匹配，功能强大。

let number = 2;
let result = match number {
    1 => "One",
    2 => "Two",
    _ => "Other",
};

易错点：确保处理所有可能性，使用 _ 作为通配符。

8. 泛型

Rust 支持泛型，允许在函数、结构体等定义中使用类型参数。

struct Point {
    x: T,
    y: T,
}

注意事项：泛型通常与 trait 约束一起使用，以便在不同类型之间共享代码。

9. 错误处理

Rust 使用 Result 类型处理错误，包含 Ok 和 Err 分支。

fn divide(a: i32, b: i32) -> Result {
    if b == 0 {
        Err("Division by zero".to_string())
    } else {
        Ok(a / b)
    }
}

注意事项：使用 ? 语法链式调用错误处理。

10. 并发编程

Rust 使用 thread 和 async 进行并发编程。

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("Hello from thread!");
    });

    handle.join().unwrap();
}

注意事项：多线程操作需谨慎使用可变变量，推荐使用 Mutex 等工具确保安全。

高级与小众用法

Trait 和 Trait 约束

Traits 用于定义共享行为，trait 约束用于泛型函数或结构体。

trait Describable {
    fn describe(&self) -> String;
}

impl Describable for Person {
    fn describe(&self) -> String {
        format!("{} is {} years old.", self.name, self.age)
    }
}

注意事项：实现 trait 时确保所有方法都实现，否则会导致编译错误。

闭包与高阶函数

Rust 支持闭包，可以捕获周围环境的变量。

let add_one = |x: i32| x + 1;
println!("{}", add_one(5));

易错点：闭包自动推断参数和返回类型，但在复杂场景中需显式声明。

生命周期

Rust 使用生命周期注解确保引用有效性。

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

注意事项：生命周期不会改变数据的生命周期，而是描述引用之间的关系。

智能指针 (Box, Rc, RefCell)

Rust 提供多种智能指针以管理复杂的内存结构。

use std::rc::Rc;

let a = Rc::new(5);
let b = Rc::clone(&a);

易错点：Rc 仅适用于单线程环境，使用 Arc 支持多线程。

异步编程

Rust 使用 async 和 await 支持异步编程。

async fn say_hello() {
    println!("Hello, world!");
}

注意事项：异步函数需返回 Future，在多线程中使用需显式调度。

宏定义

Rust 支持宏以生成重复代码，如 println!。

macro_rules! say_hello {
    () => {
        println!("Hello, world!");
    };
}

易错点：宏代码复杂度较高，建议初学者慎用。