Rust8.1SmartPointers

Rust学习笔记

Rust编程语言入门教程课程笔记

参考教材: The Rust Programming Language (by Steve Klabnik and Carol Nichols, with contributions from the Rust Community)

Lecture 15: Smart Pointers

src/main.rs

use crate::List::{Cons, Nil}; use std::ops::Deref; use crate::RcList::{RcCons, RcNil}; use std::rc::Rc; use std::cell::RefCell; use crate::List2::{Cons2, Nil2}; use crate::List3::{Cons3, Nil3}; use std::rc::Weak; fn main() { //reference counting //Rc<T> allows multiple ownership of immutable data //Example: String and Vec<T> //Trait //Deref: allows an instance of a smart pointer to behave like a reference //Drop: allows you to customize the code that is run when an instance of the smart pointer goes out of scope //The most common smart pointers in the standard library //Box<T> for allocating values on the heap //Rc<T>, a reference counting type that enables multiple ownership //Ref<T> and RefMut<T>, accessed through RefCell<T>, a type that enforces the borrowing rules at runtime instead of compile time //Box<T> let b = Box::new(5); println!("b = {}", b); //Recursive Types let _list = Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil)))))); //Deref Trait //If a struct implements the Deref trait, we can use the * operator //to dereference an instance of that struct //Rust will analyze the types and use Deref::deref as many times as necessary //to get a reference to match the parameter's type let x = 5; let y = &x; let z = Box::new(x); let zz = MyBox::new(x); assert_eq!(5, x); assert_eq!(5, *y); assert_eq!(5, *z); assert_eq!(5, *zz); //Deref coercion //Rust does deref coercion when it finds types and trait implementations in three cases: //From &T to &U when T: Deref<Target=U> let m = MyBox::new(String::from("Rust")); hello(&m);//hello(&(*m)[..]); hello("Rust"); //Drop Trait //in the prelude let c = CustomSmartPointer { data: String::from("my stuff") }; drop(c);//force a value to be dropped sooner than the end of its scope let d = CustomSmartPointer { data: String::from("other stuff") }; println!("CustomSmartPointers created."); //Output: //CustomSmartPointers created. //Dropping CustomSmartPointer with data `other stuff`! //Dropping CustomSmartPointer with data `my stuff`! //Rust automatically called drop for us when our instances went out of scope, //calling the code we specified. //Variables are dropped in the reverse order of their creation, so d was dropped before c. //Rc<T> Reference Counted Smart Pointer //Rc<T> enables multiple owners of the same data; Box<T> and RefCell<T> have single owners. //Rc<T> keeps track of the number of references to a value which determines whether or not a value is still in use. //If there are zero references to a value, the value can be cleaned up without any references becoming invalid. //Rc<T> is only for use in single-threaded scenarios. //Rc<T> is only for use in single-threaded scenarios let list_a = Rc::new(RcCons(5, Rc::new(RcCons(10, Rc::new(RcNil))))); println!("count after creating list_a = {}", Rc::strong_count(&list_a));//1 let list_b = RcCons(3, Rc::clone(&list_a));//Rc::clone doesn't make a deep copy of all the data like most types' implementations of clone do. println!("count after creating list_b = {}", Rc::strong_count(&list_a));//2 { let list_c = RcCons(4, Rc::clone(&list_a)); println!("count after creating list_c = {}", Rc::strong_count(&list_a));//3 } println!("count after list_c goes out of scope = {}", Rc::strong_count(&list_a));//2 //RefCell<T> and the Interior Mutability Pattern //RefCell<T> is useful when you’re sure your code follows the borrowing rules but the compiler is unable to understand and guarantee that. //RefCell<T> can only be used in single-threaded scenarios. let value = Rc::new(RefCell::new(5)); let a = Rc::new(Cons2(Rc::clone(&value), Rc::new(Nil2))); let b = Cons2(Rc::new(RefCell::new(6)), Rc::clone(&a)); let c = Cons2(Rc::new(RefCell::new(10)), Rc::clone(&a)); *value.borrow_mut() += 10;//borrow_mut returns a RefMut<T> smart pointer println!("a after = {:?}", a); println!("b after = {:?}", b); println!("c after = {:?}", c); //Other Smart Pointers //Cell<T>: a type that internally uses RefCell<T> but also can be copied //Mutex<T>: a type of smart pointer that locks access to the inner data using a mutex //Reference Cycles Can Leak Memory //Rc<T> allows you to have multiple owners of some data, but it doesn’t let you mutate that data. //If we want to mutate data, we need to use the interior mutability pattern. //RefCell<T> allows us to mutate contents inside an Rc<T>. //RefCell<T> keeps track of how many Ref<T> and RefMut<T> smart pointers are currently active. //When either kind of smart pointer is dropped, RefCell<T> will decrease the count of the number of smart pointers that are active. //When the count of either goes back to zero, the RefCell<T> will reclaim its inner value. let a = Rc::new(Cons3(5, RefCell::new(Rc::new(Nil3)))); println!("a initial rc count = {}", Rc::strong_count(&a));//1 println!("a next item = {:?}", a.tail());//Some(RefCell { value: Nil3 }) let b = Rc::new(Cons3(10, RefCell::new(Rc::clone(&a)))); println!("a rc count after b creation = {}", Rc::strong_count(&a));//2 println!("b initial rc count = {}", Rc::strong_count(&b));//1 println!("b next item = {:?}", b.tail());//Some(RefCell { value: Cons3(5, RefCell { value: Nil3 }) }) if let Some(link) = a.tail() { *link.borrow_mut() = Rc::clone(&b); } println!("b rc count after changing a = {}", Rc::strong_count(&b));//2 println!("a rc count after changing a = {}", Rc::strong_count(&a));//2 //println!("a next item = {:?}", a.tail());//Some(RefCell { value: Cons3(10, RefCell { value: Cons3(5, RefCell { value: Cons3(10, RefCell { value: Nil3 }) }) }) }) //Weak References let leaf = Rc::new(Node { value: 3, parent: RefCell::new(Weak::new()),//Weak::new() creates a Weak<T> that doesn’t have an owner children: RefCell::new(vec![]), }); println!("leaf strong = {}, weak = {}", Rc::strong_count(&leaf), Rc::weak_count(&leaf));//1, 0 println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());//None { let branch = Rc::new(Node { value: 5, parent: RefCell::new(Weak::new()),//Weak::new() creates a Weak<T> that doesn’t have an owner children: RefCell::new(vec![Rc::clone(&leaf)]), }); *leaf.parent.borrow_mut() = Rc::downgrade(&branch);//Rc::downgrade creates a Weak<T> from a Rc<T> reference println!("branch strong = {}, weak = {}", Rc::strong_count(&branch), Rc::weak_count(&branch));//1, 1 println!("leaf strong = {}, weak = {}", Rc::strong_count(&leaf), Rc::weak_count(&leaf));//2, 0 } println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());//Some(Node { value: 5, parent: RefCell { value: None }, children: RefCell { value: [Node { value: 3, parent: RefCell { value: None }, children: RefCell { value: [] } }] } }) println!("leaf strong = {}, weak = {}", Rc::strong_count(&leaf), Rc::weak_count(&leaf));//1, 0 } //Recursive Types enum List { Cons(i32, Box<List>),//Box<List> is a pointer to another List. This has a known size. Nil, } //define a smart pointer struct MyBox<T>(T); //implement Deref trait for MyBox<T> impl<T> MyBox<T> { fn new(x: T) -> MyBox<T> { MyBox(x) } } impl<T> Deref for MyBox<T> {//implement Deref trait for MyBox<T> type Target = T;//associated type for the Deref trait to use fn deref(&self) -> &T {//return a reference to the value we want to access with the * operator &self.0 } } fn hello(name: &str) { println!("Hello, {}!", name); } struct CustomSmartPointer { data: String, } impl Drop for CustomSmartPointer {//implement Drop trait fn drop(&mut self) {//drop method println!("Dropping CustomSmartPointer with data `{}`!", self.data); } } enum RcList { RcCons(i32, Rc<RcList>), RcNil, } pub trait Messenger { fn send(&self, msg: &str); } pub struct LimitTracker<'a, T: Messenger> { messenger: &'a T, value: usize, max: usize, } impl <'a, T> LimitTracker<'a, T> where T: Messenger, { pub fn new(messenger: &T, max: usize) -> LimitTracker<T> { LimitTracker { messenger,//messenger: messenger, value: 0, max, } } pub fn set_value(&mut self, value: usize) { self.value = value; let percentage_of_max = self.value as f64 / self.max as f64; if percentage_of_max >= 1.0 { self.messenger.send("Error: You are over your quota!"); } else if percentage_of_max >= 0.9 { self.messenger.send("Urgent warning: You've used up over 90% of your quota!"); } else if percentage_of_max >= 0.75 { self.messenger.send("Warning: You've used up over 75% of your quota!"); } } } #[derive(Debug)] enum List2 { Cons2(Rc<RefCell<i32>>, Rc<List2>), Nil2, } #[derive(Debug)] enum List3 { Cons3(i32, RefCell<Rc<List3>>), Nil3, } impl List3 { fn tail(&self) -> Option<&RefCell<Rc<List3>>> { match self { Cons3(_, item) => Some(item), Nil3 => None, } } } #[derive(Debug)] struct Node { value: i32, parent: RefCell<Weak<Node>>, children: RefCell<Vec<Rc<Node>>>, } #[cfg(test)] mod tests { use super::*; struct MockMessenger { sent_messages: RefCell<Vec<String>>, } impl MockMessenger { fn new() -> MockMessenger { MockMessenger { sent_messages: RefCell::new(vec![])} } } impl Messenger for MockMessenger { fn send(&self, message: &str) { self.sent_messages.borrow_mut().push(String::from(message)); //borrow_mut returns a RefMut<T> smart pointer //Every time we call borrow_mut, the mutable borrow counter goes up by one. //When a RefMut<T> value goes out of scope, the mutable borrow counter goes down by one. } } #[test] fn it_sends_an_over_75_percent_warning_message() { let mock_messenger = MockMessenger::new(); let mut limit_tracker = LimitTracker::new(&mock_messenger, 100); limit_tracker.set_value(80); assert_eq!(mock_messenger.sent_messages.borrow().len(), 1); //borrow returns a Ref<T> smart pointer //Every time we call borrow, the immutable borrow counter goes up by one. //When a Ref<T> value goes out of scope, the immutable borrow counter goes down by one. } }