Rust8.1 Smart Pointers
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 allows multiple ownership of immutable data
//Example: String and Vec for allocating values on the heap
//Rc, a reference counting type that enables multiple ownership
//Ref and RefMut, accessed through RefCell, a type that enforces the borrowing rules at runtime instead of compile time
//Box Reference Counted Smart Pointer
//Rc enables multiple owners of the same data; Box and RefCell have single owners.
//Rc 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 is only for use in single-threaded scenarios.
//Rc 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 and the Interior Mutability Pattern
//RefCell is useful when you’re sure your code follows the borrowing rules but the compiler is unable to understand and guarantee that.
//RefCell 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 smart pointer
println!("a after = {:?}", a);
println!("b after = {:?}", b);
println!("c after = {:?}", c);
//Other Smart Pointers
//Cell: a type that internally uses RefCell but also can be copied
//Mutex: a type of smart pointer that locks access to the inner data using a mutex
//Reference Cycles Can Leak Memory
//Rc 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 allows us to mutate contents inside an Rc.
//RefCell keeps track of how many Ref and RefMut smart pointers are currently active.
//When either kind of smart pointer is dropped, RefCell will decrease the count of the number of smart pointers that are active.
//When the count of either goes back to zero, the RefCell 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 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 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 from a Rc 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 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 smart pointer
//Every time we call borrow_mut, the mutable borrow counter goes up by one.
//When a RefMut 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 smart pointer
//Every time we call borrow, the immutable borrow counter goes up by one.
//When a Ref value goes out of scope, the immutable borrow counter goes down by one.
}
}