Rust高级特性

目录

• 高级特性
  • Rust的安全性
  • 高级trait
  • 高级类型
  • 高级函数和闭包
  • 宏

高级特性

Rust 的安全性

内存安全 Rust 通过所有权、借用和生命周期机制确保内存安全。

所有权

• 每个值都有一个所有者，当所有者离开作用域时，该值会被自动释放。

fn main() {
    let s = String::from("hello"); // s 是所有者
    {
        let r = &s; // r 是借用
    } // r 离开作用域，借用结束
    println!("{}", s); // s 仍然有效
}

借用规则

• 借用不能同时存在可变借用和不可变借用。
• 借用必须在所有者的生命周期内。

fn main() {
    let mut s = String::from("hello");
    {
        let r1 = &s; // 不可变借用
        let r2 = &s; // 可以存在多个不可变借用
        println!("{} and {}", r1, r2);
    }
    let r3 = &mut s; // 可变借用
    println!("{}", r3);
}

生命周期

• 确保引用不会超出其被引用的数据的生命周期。

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 result = longest(string1.as_str(), "xyz");
    println!("The longest string is {}", result);
}

并发安全

• Rust 的所有权机制同样适用于并发场景，确保线程安全。

use std::sync::Mutex;
use std::thread;

fn main() {
    let counter = Mutex::new(0);

    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Mutex::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap());
}

高级 Trait

泛型 Trait 允许为不同类型定义通用行为。

trait Displayable {
    fn display(&self);
}

impl Displayable for i32 {
    fn display(&self) {
        println!("Integer: {}", self);
    }
}

impl Displayable for String {
    fn display(&self) {
        println!("String: {}", self);
    }
}

fn main() {
    let number = 42;
    let message = String::from("Hello, world!");

    number.display();
    message.display();
}

高级 Trait Bound 限制泛型参数的类型约束。

trait Summary {
    fn summarize(&self) -> String;
}

impl Summary for String {
    fn summarize(&self) -> String {
        format!("Summary: {}", self)
    }
}

fn print_summary<T: Summary>(item: T) {
    println!("Summary: {}", item.summarize());
}

fn main() {
    let message = String::from("Hello, world!");
    print_summary(message);
}

默认方法 为 Trait 实现默认方法。

trait Greeting {
    fn greet(&self) -> String;
    fn default_greet(&self) -> String {
        format!("Hello, {}", self)
    }
}

impl Greeting for String {
    fn greet(&self) -> String {
        format!("Greeting: {}", self)
    }
}

fn main() {
    let name = String::from("Alice");
    println!("{}", n...