Rust 知识积累(5)

&str

字符串
  • 直接声明时,生命周期为整个程序,直接写进了二进制中,类型为&'static str',意为字符串字元有一个叫static的生命期
借用str
  • 作为String的引用来使用,无生命期,例如 fn print_str(my_str: &str){},调用为print_str(&String::format("string""));

生命期

  • 引用的生命期不能比这个对象长

    fn returns_str() -> &str{
        return "I am" // ---错误,因为这个值声明是在方法内,引用出去后是null
    }
    // 改进
    fn returns_str() -> &‘static str{
        return "I am" // ---正确,返回了字符串字面量,该值整个程序有效
    }
    

struct使用

  • 基础使用

    // 尝试写struct City<'a>和name: &'a str
    // 意思是 name可以存活到与City一样的生命期
    // a可以为任意值
    #[derive(Debug)]
    struct City<'a>{
        name: &'a str,
        date_f: u32,
    }
    let my_city = City{
        name: &"China".to_string(),
        date_f: 2022,
    }
    
  • 添加调用方法

    // 不仅仅struct要与name同一个生命期,impl也要一致
    struct Adventurer<'a>{
        name: &'a str,
        hit_points: u32,
    }
    impl Adventer<'_>{
        fn take_damage(&mut self){
            slef.hit_points -= 20;
            println!("{} has {} hit", slef.name, self.hit_points);
        }
    }
    fn main(){
        let mut bi = Adventurer{
            name:"Billy",
            hit_points: 100,
        }
        bi.take_damage();
    }
    

内部可变性

  • 不用mut也可修改数据,例如Cell,RefCell,Mutex, RwLock

  • Cell

    // 给出的是值而不是引用
    use std::cell::Cell;
    struct PhoneModel{
        on_sale: Cell<bool>,
    }
    fn main(){
        let huawei_phone = PhoneModel{
            on_sale: Cell::new(true),
        };
        huawei_phone.on_sale.set(false);
    }
    
  • RefCell

    // 引用单元格,引用
    // 小心使用,他是运行后编译
    use std::cell::RefCell;
    struce User{
        active: RefCell<bool>,
    }
    fn main(){
        let user_l = user{
            active: RefCell::new(true),
        };
        println!("{}", user_l.active);
    
        user_l.active.borrow();
        user_l.active.borrow_mut(); //引出后就不能再borrow_mut()了
        user_l.active.replace(false);
    
    }
    
  • Mutex

    线程安全,只让一个线程修改它(有lock())

    use std::sync::Mutex;
    let my_mutex = Mutex::new(5);
    // 加锁
    let mut mutex_changer = my_mutex.lock().unwarp();
    // 加锁后修改,也可大括号括起来,括号外自己解锁(超出加锁范围)
    *mutex_changer = 6;
    // 解锁
    std::mem::drop(mutex_changer);
    // 判断是否可用
    if let Ok(value) = my_mutex.try_lock(){
        //没加锁
    }else{
        // 加锁
    }
    
    // 直接赋值,不需要解锁
    *my_mutex.lock().unwarp() = 6;
    
  • RwLock

    1. 读写锁 类似于Mutex和RefCell

    2. 多个.read() 可以,一个.write() 可以

    use std::sync::RwLock;
    let my_rwlock = RwLock::new(5);
    let read1 = my_rwlock.read().unwrap(); // 多个read都可以
    let read2 = my_rwlock.read().unwrap();// 多个read都可以
    drop(read1); 
    drop(read2); // 两个read()都进行了解锁,因此可以write()
    let mut write1 = my_rwlock.write().unwarp();
    *write1 = 6;
    drop(write1); // 解锁后可继续操作
    
    if let Ok(mut number) = my_rwlock.try_write(){
        *number += 10
    }else{
        // 锁住了
    }
    

Cow

  • 枚举,写时克隆

    // 说明: 当类型为B时,返回 Borrowed(&'a B), 否则 Owned(<B as ToOwned>:Owned)
    pub enum Cow<'a, B> where B: 'a + ToOwned + ?Size,{
        Borrowed(&'a B),
        Owned(<B as ToOwned>:Owned),
    }
    // Cow<'static, str>判断时为
    // Cow::Borrowed(message) : message 为 实际值
    // Cow::Owned(message) : message 为 实际值
    //注意,返回的数值是str
    fn modulo_3(input: u8) -> Cow<'static, str> {
        match input % 3 {
            0 => "Remainder is 0".into(),
            1 => "Remainder is 1".into(),
            remainder => format!("Remainder is {}", remainder).into(), // 这个为String,因此会变成Cow::Owned()
        }
    }
    
    fn main() {
        for number in 1..=6 {
            match modulo_3(number) {
                Cow::Borrowed(message) => println!("{} went in. The Cow is borrowed with this message: {}", number, message),
                Cow::Owned(message) => println!("{} went in. The Cow is owned with this message: {}", number, message),
            }
        }
    }
    

类型别名

  • 声明别名的几种方式及使用

    //方式一
    type CharacterVec = Vec<char>;
    //方式二
    type SkipFourTakeFive<'a> = std::iter::Take<std::iter::Skip<std::slice::Iter<'a, char>>>;
    fn returns<'a>(input: &'a Vec<char>) -> SkipFourTakeFive {
        input.iter().skip(4).take(5)
    }
    //方式三
    use std::iter::{Task, Skip};
    use std::slice::Iter;
    fn returns<'a>(input: &'a Vec<char>) -> Take<Skip<Iter<'a, char>>> {
        input.iter().skip(4).take(5)
    }
    //方式四
    struct File(String); // File is a wrapper around String
    
    fn main() {
        let my_file = File(String::from("I am file contents"));
        let my_string = String::from("I am file contents");
        println!("{}", my_file == my_string);  // ⚠️ 错误,不能比较,因为类型不对
        println!("{}", my_file.0 == my_string);//      正确
    }
    //方式五 enum枚举简单调用
    enum MapDirection{
        North, East,
    }
    fn main(){
        use MapDirection::*;
        //后面可直接使用 MapDirction
        match direction{
            North => println!(),
            East => println!();
        }
        // 也可以进行改名
        use MapDirection::{
            North as N,
            East as E,
        }
    }
    

todo! 宏

  • 还未想好如何操作,但是又要运行,可以用 todo!()

    fn get_book(book: &Book) -> Option<String> {
        todo!() // todo means "I will do it later, please be quiet"
    }
    

Rc

  • 使用数量变为0,才会消失

    use std::rc:Rc;
    let history = Rc::new("".to_string());
    let h2 = history.clone() // Rc的计数变为了2
    println!("{}", Rc::strong_count(&history)); //强引用数量
    Rc::downgrade(&item) 来创建弱引用 //如果只有弱引用,则变量会消失
    Rc::weak_count(&item) 查看弱引用数
    

多线程

  • std ::thread ::spawn 创建线程

    fn main(){
        //当主程序结束,线程还未结束时,会报异常
        std::thread::spawn(||{
            println!("");
        });
        // 改进 将线程绑定到变量上
        let handle = std::thread::spawn(||{
            println!("");
        });
        handle.join();
        
        // 取值
        let mut my_str = String::form("");
        let handle = std::thread::spawn(move || { // 使用move来获得线程外的数值
            println!("{}", my_str);
        });
        handle.join();
    }
    

闭包

  • FnOnce: 取整个值

  • FnMut : 取一个可变引用

  • Fn : 取一个普通引用

  • 各种方式举例

    // fn方式
    let my_str = String::form("string");
    let my_closure = || println!("{}", my_str);
    my_closure();   //可多次调用    
    my_closure(); // String没有实现copy,因此是Fn
    
    // FnMut方式
    let mut my_str = String::form("string");
    let mut my_closure = || {
        my_str.push_str(" clone");
        println!("{}", my_str);
    }
    my_closure();   //可多次调用,my_str会新增clone字符串
    my_closure();   // 如果改变my_str, 就变成了FnMut
    
    //  FnOnce方式
    let my_vec: Vec<i32> = vec![8, 9, 10];
    let my_closure = || {
        my_vec
        .into_iter() // into_iter takes ownership
        .map(|x| x as u8) // turn it into u8
        .map(|x| x * 2) // multiply by 2
        .collect::<Vec<u8>>() // collect into a Vec
    };
    let new_vec = my_closure(); //只能使用一次
    
posted @ 2023-03-22 15:16  摧残一生  阅读(43)  评论(0编辑  收藏  举报