社区首页 >专栏 >2023学习日志

2023学习日志

原创

TomoriNao

发布于 2023-07-27 13:29:01

1960

文章被收录于专栏：每月技术成长每月技术成长

rust

智能指针

Box<T>指针

在堆上存储数据，而指针本身位于栈上 Box<T>类型的智能指针创建的是指向堆数据的指针，初始化过程中，会将数据分配在堆上，能够有效地节省栈上有限的空间，在所有权转移的过程中，复制的仅仅是一个栈上的指针，而非实际的数据，能够提高程序的性能 示例：

    fn main() {
        let b = Box::new(5);
        println!("b = {}",b);
    }

允许创建递归类型 对于常见的cons list类型的数据结构（嵌套的列表），如果直接在声明结构体时进行嵌套，rust的编译器无法推断出该类型数据占用的内存大小，会在编译时报错。示例：

//编译时将报错，无法推断出List结构体的具体大小
    use crate::List::{Cons, Nil};
    enum List{
        Cons(i32,List),
        Nil,
    }
    fn main(){
        let list = Cons(1, Cons(2, Cons(3, Nil)));
    }

此时可以使用Box<T>指针指向嵌套的列表，得到cons list类型的结构体。（指针的内存大小是已知的，但列表的大小是在进行结构体声明时未知的）

示例：

// 此段代码不会报错，因为Box<T>为智能指针，大小固定，编译器可以推断出List类型的大小
    use crate::List::{Cons, Nil};
    enum List{
        Cons(i32, Box<List>),
        Nil
    }
    fn main(){
        let list = Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil))))));
    }

超出作用域之后，自动释放堆上数据在超出作用域后，栈上的数据都会被逐一清除，而Box<T>智能指针在清除之前会调用其实现了的Drop trait的drop函数，清除所指向的堆上的数据。

Deref Trait 重载解引用运算符

智能指针类型的变量本身为指针类型，在使用时需要进行解引用来得到其所指向的数据。而解引用需要重载解引用运算符&。而通过实现Deref Trait，能够将类型像引用一样处理。

Deref trait需要实现其定义的deref方法，返回一个内部数据的引用。

示例：

    //为Mybox<T>类型实现Deref trait
    use std::ops::Deref;
    impl<T> Deref for MyBox<T> {
        type Target = T;
        fn deref(&self) -> &self::Target {
            &self.0
        }
    }
    struct MyBox<T>(T);
    impl<T> MyBox<T> {
        fn new(x: T) -> MyBox<T> {
            MyBox(x)
        }
    }
    fn main() {
        let x=5;
        let y = MyBox::new(x);
        assert_eq!(5, x);
        assert_eq!(5, *y);
    }

Drop Trait 自动清除数据

Drop trait 类似于c++中的析构函数，在变量离开作用域时调用，清除数据或进行一些其他操作。

实现Drop trait需要实现其drop方法，该方法在变量离开时被调用，完成指定的一些操作。（主要目的为清理该变量拥有的数据）

此外，还可通过std::mem::drop 来在作用域结束前释放变量，std::mem::drop位于prelude中，因此无需显式引入该方法。

示例：

    //为CustomSmartPointer结构体实现Drop trait
    struct CustomSmartPointer {
        data: String,
    }
    impl Drop for CustomSmartPointer {
        fn drop (&mut self){
            println!("Droping CustomSmartPointer with Data `{}`", self.data);
        
        }
    }
    fn main() {
        let c = CustomSmartPointer{
            data: String::from("my stuff"),
        };
        drop(c);
        let d = CustomSmartPointer{
            data: String::from("other stuff"),
        };
        println!("CustomSmartPointer created.");
    }

Rc<T>指针

Rc<T> 用于当我们希望在堆上分配一些数据供程序的多个部分读取，且无法在编译时确定程序的哪一部分会最终结束使用它的时候，如果确实知道哪部分是最后结束使用的话，可以令其成为数据的所有者，正常的所有权规则在编译时生效。

可以通过克隆Rc<T>的方式获取对堆上数据的引用，每次克隆时，引用计数增加1，当一个Rc<T>指针离开作用域时，引用计数减1，而当引用计数为0时，对应的drop方法将会被调用，堆上数据将会被清理。

注意：Rc<T>克隆的结果为不可变引用，rust不允许同时存在多个可变引用。

强引用 --Rc<T> Rc<T>指针为强引用，可以通过调用Rc::clone方法返回一个Rc<T>指针，会导致引用计数发生变化，当引用计数为0时，指针所指向的堆上数据将会被清理
弱引用 --Weak<T> Weak<T>指针为弱引用，可以通过Rc::downgrade方法返回一个*Weak<T>指针，不会导致引用计数发生变化，不会对堆上数据的清理产生影响因为Weak<T>引用的值可能已经被丢弃了，因此需要在使用Weak<T>所指向的值时，调用Weak<T>实例的upgrade方法，返回一个Option<Rc<T>>

示例：

    use crate::List::{Cons, Nil};
    use std::rc::Rc;
    enum List {
        Cons(i32, Rc<List>),
        Nil,
    }
    fn main(){
        let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
        println!("count after creating a = {}", Rc::strong_count(&a));
        //Rc::clone得到的是Rc<T>类型的强引用，会影响引用计数
        let b = Cons(3, Rc::clone(&a));
        println!("count after creating b =  {}", Rc::strong_count(&a));
        {
            let c = Cons(4, Rc::clone(&a));
            println!("count after creating c = {}", Rc::strong_count(&a));
        }
        println!("count after c goes out of scope = {}", Rc::strong_count(&a));
    }

RefCell<T>指针

内部可变性 内部可变性是rust中的一个设计模式，它允许你即使在有不可变引用时也可以改变数据，这通常是借用规则不允许的。该模式使用unsafe代码来模糊rust的可变性和借用规则。当可以确保代码在运行时会遵守借用规则，即使是编译器无法保证的情况，可以选择使用运用了内部可变性模式的类型。
RefCell<T>运行时检查借用规则 RerCell<T>遵循内部可变性模式，在运行时检查借用规则而非编译时。因为RefCell<T>允许在运行时检查借用规则，因此可以在RefCell自身不可变的情况修改其内部的值。示例：

    use std::cell::RefCell;
    trait Messenger {
        fn send(&self, msg: &str);
    }
    struct MockMessenger {
        sent_messages: RefCell<Vec<String>>,
    }
    impl Messager for MockMessenger {
        fn send(&self, message: &str) {
            //borrow_mut()方法获取的是RefMut<T>类型的智能指针，borrow()方法获取的是Ref<T>类型的智能指针
            self.sent_message.borrow_mut().push(String::from(message));
        }
    }

RefCell<T>在运行时记录借用 borrow_mut方法获取的是RefMut<T>类型的智能指针，borrow方法获取的是Ref<T>类型的智能指针 RefCell<T>记录当前有多少个活动的Ref<T>和RefMut<T>智能指针，每次调用borrow方法，RefCell<T>将不可变借用计数加一，当Ref<T>指针离开作用域时，不可变计数减一。可变借用计数规则类似不可解压计数规则。与编译时借用规则相同：RefCell<T>在任何时刻只允许存在多个不可变借用或一个可变借用。示例：

    impl Messenger for MockMessenger {
        fn send(&self, message: &str){
            //代码将报错，不能同时存在两个可变借用
            let mut one_borrow = self.sent_message.borrow_mut();
            let mut two_borrow = self.sent_message.borrow_mut();
        }
    }