Rust基础

rust的特性

一、所有权系统

所有权机制： rust拥有独特的所有权系统，确保在编译时就能够管理内存安全，避免了常见的内存错误，如空指针引用、野指针、悬垂指针和数据竞争等。每个值都有一个所有者，并且在同一时间只有一个所有者，当所有者离开作用域时，其拥有的值会被自动释放。

fn main(){
    let s=String::new();//当s离开main函数的作用域时，String的内存会被自动释放
}

借用规则：可以通过引用（借用）来访问数据而不获取所有权。引用分为不可变引用（&T）和可变引用（&mut T）可以有多个不可变引用，但在同一时间只能有一个可变引用，防止了数据竞争。
生命周期

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

二、模式匹配

强大的模式匹配：

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

fn main(){
    let msg=Message::ChangeColor(255,0,0);
    match msg{
        Message::Quit=>println!("quit"),
        Message::Move{x,y}=>println!("move to x={},y={}",x,y),
        Message::Write(s)=>println!("write {}",s),
        Message::ChangeColor(r,g,b)=>println!("change color to r={},g={},b={}",r,g,b),
    }
}

匹配守卫和绑定：

fn main(){
    let num=Some(5);
    if let Some(x)=num{
        if x>10{
            println!("x is greater than 10");
        }else{
            println!("x is less than 10");
        }
    }
}

三、错误处理

Result和Option类型：

use std::fs::File;

fn main(){
    let f=File::open("test.txt");
    match f{
        Ok(file)=>println!("File opened:{:?}",file),
        Err(e)=>println!("Error opening file:{}",e),
    }
}

?操作符

use std::fs::File;
use std::io::Read;

fn read_file()->Result<String,std::io::Error>{
    let mut f=File::open("test.txt")?;
    let mut s=String::new();
    f.read_to_string(&mut s)?;
    Ok(s)
}

fn main(){
    match read_file(){
        Ok(s)=>println!("File contents:{}",s),
        Err(e)=>println!("Error reading file:{}",e),
    }
}

四、模块和包管理

模块系统：

mod my_module{
    pub fn hello(){
        println!("Hello from my module!");
    }
}
fn main(){
    my_module::hello();
}

cargo包管理

五、并发和执行

安全的并发

use std::thread;

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

    handle.join().unwrap();
}

send和sync标记特征：

六、宏系统

声明宏和过程宏：

macro_rules! say_hello{
    ()=>(
        println!("hello world!");
    );
}
fn main(){
    say_hello!();
}

七、抽象

迭代器、闭包、trait

fn main(){
    let v=vec![1,2,3];
    let sum:i32=v.iter().map(|x| x*2).sum();
    println!("{}",sum);
}

八、安全的FFI支持

外部函数接口（FFI）：

extern "C"{
    fn sqrt(x:f64)->f64;
}

fn main(){
    unsafe{
        let result=sqrt(4.0);
        println!("{}",result);
    }
}

九、零碎知识

闭包：闭包是一种匿名函数，它可以赋值给变量也可以作为参数传递给其它函数，不同于函数的是，它允许捕获调用者作用域中的值。

fn main(){
    let x=1;
    let sum=|y| x+y;
    assert_eq!(3,sum(3));
}

use std::thread;
use std::time::Duration;

fn workout(intensity: u32, random_number: u32) {
    let action = || {
        println!("muuuu.....");
        thread::sleep(Duration::from_secs(2));
        intensity
    };

    if intensity < 25 {
        println!(
            "今天活力满满，先做 {} 个俯卧撑!",
            action()
        );
        println!(
            "旁边有妹子在看，俯卧撑太low，再来 {} 组卧推!",
            action()
        );
    } else if random_number == 3 {
        println!("昨天练过度了，今天还是休息下吧！");
    } else {
        println!(
            "昨天练过度了，今天干干有氧，跑步 {} 分钟!",
            action()
        );
    }
}

fn main() {
    // 动作次数
    let intensity = 10;
    // 随机值用来决定某个选择
    let random_number = 7;

    // 开始健身
    workout(intensity, random_number);
}