Rust模式匹配、所有权与借用

目录

• 所有权与借用
  • 所有权
  • 引用与借用
• 流程控制
• 模式匹配
  • match和iflet
  • 解构Option
  • 模式适用场景
  • 全模式列表
• 方法method

所有权与借用

所有权 (Ownership)

所有权机制是 Rust 中管理内存的核心方式。每个值都有一个所有者，而且任何时候只能有一个所有者。当所有者离开作用域时，该值会被自动清理。

基本所有权规则

• 每个值都有一个所有者。
• 只有当所有者离开作用域时，值才会被清理。

所有权转移 当你将一个值赋给另一个变量时，原来的变量将不再拥有该值。

示例代码：

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // 所有权转移

    println!("{}", s2); // 输出 "hello"
    // println!("{}", s1); // 编译错误：s1 已经不再有效
}

借用 (Borrowing)

借用允许你在不改变所有权的情况下访问值。Rust 有两种类型的借用：不可变借用和可变借用。

不可变借用 不可变借用允许你读取但不能修改值。

fn main() {
    let s = String::from("hello");

    let len = calculate_length(&s); // 不可变借用

    println!("The length of '{}' is {}.", s, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

可变借用 可变借用允许你修改值，但同一时间内只能有一个可变借用。

fn main() {
    let mut s = String::from("hello");

    change(&mut s); // 可变借用

    println!("{}", s); // 输出 "hello world"
}

fn change(s: &mut String) {
    s.push_str(" world");
}

借用规则 在同一时间内，只能有一个可变借用或者任意数量的不可变借用。 借用必须在有效的作用域内。

生命周期 (Lifetimes)

生命周期确保引用不会超出其所有者的生命周期。生命周期注解用于明确指明引用的有效范围。

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

fn main() {
    let string1 = String::from("long string is long");
    let string2 = String::from("xyz");

    let result = longest(string1.as_str(), string2.as_str());
    println!("The longest string is {}", result);
}

综合示例：所有权与借用

下面是一个综合示例，展示了所有权和借用在实际应用中的使用。

示例代码：字符串处理

fn main() {
    let mut s = String::from("hello");

    // 不可变借用
    let len = calculate_length(&s);
    println!("Length: {}", len);

    // 可变借用
    change(&mut s);
    println!("After change: {}", s);

    // 使用生命周期注解
    let result = longest_with_lifetime(&s, "world");
    println!("Longest: {}", result);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

fn change(s: &mut String) {
    s.push_str(" world");
}

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

流程控制

条件语句

使用 if 和 else 进行条件判断。

示例代码：

fn main() {
    let number = 5;

    if number % 2 == 0 {
        println!("number is even");
    } else {
        println!("number is odd");
    }
}

循环语句

• while 循环
• for 循环

fn main() {
    let mut count = 0;

    while count < 5 {
        println!("count is {}", count);
        count += 1;
    }

    for i in 0..5 {
        println!("i is {}", i);
    }
}

模式匹配

模式匹配是 Rust 中的一个强大特性，它可以让你以一种简洁且安全的方式处理数据结构。

match 语句

match 语句允许你根据不同的模式执行不同的代码块。

基本语法

let some_value = 1;

match some_value {
    1 => println!("One"),
    2 => println!("Two"),
    _ => println!("Anything else"),
}

解构 Option<T>

Option<T> 是 Rust 中常用的类型，表示可能为空的值。

fn main() {
    let some_option = Some(5);
    let none_option: Option<i32> = None;

    match some_option {
        Some(value) => println!("Some value: {}", value),
        None => println!("No value"),
    }

    match none_option {
        Some(value) => println!("Some value: {}", value),
        None => println!("No value"),
    }
}

解构元组

match 语句可以解构元组。

fn main() {
    let point = (1, 2);

    match point {
        (x, y) => println!("Point: ({}, {})", x, y),
    }
}

解构枚举

枚举也可以通过 match 语句进行解构。

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {
    let msg = Message::Write(String::from("hello"));

    match msg {
        Message::Quit => println!("Quit"),
        Message::Move { x, y } => println!("Move to ({}, {})", x, y),
        Message::Write(text) => println!("Write: {}", text),
        Message::ChangeColor(r, g, b) => println!("Change color to ({}, {}, {})", r, g, b),
    }
}

if let 语句

if let 语句是一种更简洁的方式来匹配单个模式。

解构 Option<T>

fn main() {
    let some_option = Some(5);
    let none_option: Option<i32> = None;

    if let Some(value) = some_option {
        println!("Some value: {}", value);
    } else {
        println!("No value");
    }

    if let Some(value) = none_option {
        println!("Some value: {}", value);
    } else {
        println!("No value");
    }
}

解构元组

fn main() {
    let point = (1, 2);

    if let (x, y) = point {
        println!("Point: ({}, {})", x, y);
    }
}

解构枚举

fn main() {
    let msg = Message::Write(String::from("hello"));

    if let Message::Write(text) = msg {
        println!("Write: {}", text);
    }
}

模式适用场景

处理 Option<T>

fn main() {
    let some_option = Some(5);
    let none_option: Option<i32> = None;

    match some_option {
        Some(value) => println!("Some value: {}", value),
        None => println!("No value"),
    }

    if let Some(value) = none_option {
        println!("Some value: {}", value);
    } else {
        println!("No value");
    }
}

处理 Result<T, E>

use std::fs::File;
use std::io::{self, Read};

fn...