Rust简单整理(c15-c17)
by wqpw
基于官方教程《The Rust Programming Language》
15. Smart Pointers
//main.rs
/*
enum List {
Cons(i32, Box<List>),
Nil,
}
use crate::List::{Cons, Nil};
fn boxtest() {
let b = Box::new(233);
println!("{}", b);
let list = Cons(1,
Box::new(Cons(2,
Box::new(Cons(3,
Box::new(Nil)))))); //(con 1 (con 2 con(3 nil)))
}
*/
struct MyBox<T>(T);
impl<T> MyBox<T> {
fn new(x: T) -> MyBox<T> {
MyBox(x)
}
}
use std::ops::Deref;
impl<T> Deref for MyBox<T> {
type Target = T;
fn deref(&self) -> &T {
&self.0
}
}
fn hello(name: &str) {
println!("Hello {}", name);
}
fn mybox_test() {
let a = MyBox::new(666);
let b = &a;
println!("{}", b.0);
let m = MyBox::new(String::from("Rust"));
hello(&m); //&MyBox<String> -> &String -(defef coercion)-> &str
//hello(&(*m)[..]);
}
/*
From &T to &U when T: Deref<Target=U>
From &mut T to &mut U when T: DerefMut<Target=U>
From &mut T to &U when T: Deref<Target=U>
&T to &mut U is impossible
*/
struct CustomSmartPointer {
data: String,
}
impl Drop for CustomSmartPointer {
fn drop(&mut self) {
println!("Dropping CustomSmartPointer with data `{}`!", self.data);
}
}
fn drop_test() {
let t = CustomSmartPointer { data: String::from("AAA") };
drop(t); //std::mem::drop early
let c = CustomSmartPointer { data: String::from("my stuff") };
let d = CustomSmartPointer { data: String::from("other stuff") };
println!("CustomSmartPointers created.");
}
//Rc<T> type keeps track of the number of references to a value
//which determines whether or not a value is still in use.
enum Rc_list {
RCons(i32, Rc<Rc_list>),
RNil,
}
use crate::Rc_list::{RCons, RNil};
use std::rc::Rc;
/*
Using Rc<T> allows a single value to have multiple owners,
and the count ensures that the value remains valid
as long as any of the owners still exist.
*/
fn rc_test() {
let a = Rc::new(RCons(5, Rc::new(RCons(10, Rc::new(RNil)))));
println!("count after creating a = {}", Rc::strong_count(&a));
let b = RCons(3, Rc::clone(&a));
println!("count after creating b = {}", Rc::strong_count(&a));
{
let c = RCons(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));
//the data won’t be cleaned up unless there are zero references to it
}
/*
The RefCell<T> type is useful
when you’re sure your code follows the borrowing rules
but the compiler is unable to understand and guarantee that.
With RefCell<T>, these invariants are enforced at runtime.
if you break these rules, your program will panic and exit.
Rc<T> enables multiple owners of the same data; Box<T> and RefCell<T> have single owners.
Box<T> allows immutable or mutable borrows checked at compile time;
Rc<T> allows only immutable borrows checked at compile time;
RefCell<T> allows immutable or mutable borrows checked at runtime.
Because RefCell<T> allows mutable borrows checked at runtime,
you can mutate the value inside the RefCell<T>
even when the RefCell<T> is immutable.
*/
#[derive(Debug)]
enum List {
Cons(Rc<RefCell<i32>>, Rc<List>),
Nil,
}
use crate::List::{Cons, Nil};
use std::cell::RefCell;
fn main() {
//boxtest();
mybox_test();
drop_test();
rc_test();
let value = Rc::new(RefCell::new(5));
let a = Rc::new(Cons(Rc::clone(&value), Rc::new(Nil)));
let b = Cons(Rc::new(RefCell::new(6)), Rc::clone(&a));
let c = Cons(Rc::new(RefCell::new(10)), Rc::clone(&a));
*value.borrow_mut() += 10;
println!("a after = {:?}", a);
println!("b after = {:?}", b);
println!("c after = {:?}", c);
}
//lib.rs
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,
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!");
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::cell::RefCell;
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));
}
}
#[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);
}
}
//The borrow method returns the smart pointer type Ref<T>,
// and borrow_mut returns the smart pointer type RefMut<T>
//tree.rs
use std::rc::{Rc, Weak};
use std::cell::RefCell;
#[derive(Debug)]
struct Node {
value: i32,
parent: RefCell<Weak<Node>>,
children: RefCell<Vec<Rc<Node>>>,
}
//A node will be able to refer to its parent node
//but doesn’t own its parent.
use std::rc::{Rc, Weak};
use std::cell::RefCell;
#[derive(Debug)]
struct Node {
value: i32,
parent: RefCell<Weak<Node>>,
children: RefCell<Vec<Rc<Node>>>,
}
//the weak_count doesn’t need to be 0 for the Rc<T> instance to be cleaned up.
fn main() {
let leaf = Rc::new(Node {
value: 3,
parent: RefCell::new(Weak::new()),
children: RefCell::new(vec![]),
});
println!(
"leaf strong = {}, weak = {}",
Rc::strong_count(&leaf),
Rc::weak_count(&leaf),
);
{
let branch = Rc::new(Node {
value: 5,
parent: RefCell::new(Weak::new()),
children: RefCell::new(vec![Rc::clone(&leaf)]),
});
*leaf.parent.borrow_mut() = Rc::downgrade(&branch);
println!(
"branch strong = {}, weak = {}",
Rc::strong_count(&branch),
Rc::weak_count(&branch),
);
println!(
"leaf strong = {}, weak = {}",
Rc::strong_count(&leaf),
Rc::weak_count(&leaf),
);
}
println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());
println!(
"leaf strong = {}, weak = {}",
Rc::strong_count(&leaf),
Rc::weak_count(&leaf),
);
}
16. Fearless Concurrency
use std::thread;
use std::time::Duration;
use std::sync::mpsc;
use std::sync::{Mutex, Arc};
fn main() {
let handle = thread::spawn(|| {
for i in 1..10 {
println!("hi number {} from the spawned thread!", i);
thread::sleep(Duration::from_millis(1));
}
});
//handle.join().unwrap();
//main will wait spawn to exit!
for i in 1..5 {
println!("hi number {} from the main thread!", i);
thread::sleep(Duration::from_millis(1));
}
handle.join().unwrap();
//make sure the spawned thread finishes before main exits
let v = vec![1, 2, 3];
let handle = thread::spawn(move || {
println!("Here's a vector: {:?}", v);
}); //move ownership, borrow possibly invalid
//drop(v); violate ownership rule
handle.join().unwrap();
//multiple producer, single consumer
//message passing
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
let val = String::from("hi");
tx.send(val).unwrap(); //moved; -> Result
});
let received = rx.recv().unwrap(); //block main until recv
println!("Got: {}", received); //other loop try_recv()
//
let (tx, rx) = mpsc::channel();
let tx1 = mpsc::Sender::clone(&tx);
thread::spawn(move || {
let vals = vec![
String::from("hi"),
String::from("from"),
String::from("the"),
String::from("thread"),
];
for val in vals {
tx.send(val).unwrap();
thread::sleep(Duration::from_secs(1));
}
});
thread::spawn(move || {
let vals = vec![
String::from("more"),
String::from("message"),
String::from("for"),
String::from("you"),
];
for val in vals {
tx1.send(val).unwrap();
thread::sleep(Duration::from_secs(1));
}
});
//When the channel is closed, iteration will end.
for received in rx {
println!("Got: {}", received);
}
//mutex allows only one thread to access some data
//at any given time. lock and unlock
let m = Mutex::new(5);
{
let mut num = m.lock().unwrap();
*num = 6;
} //out of scope, unlocked
println!("m = {:?}", m);
//Multiple Ownership with Multiple Threads
//thread-safe Atomic Reference Counting
let counter = Arc::new(Mutex::new(0));
//Mutex<T> provides interior mutability
let mut handles = vec![];
for _ in 0..10 {
let counter = Arc::clone(&counter);
let handle = thread::spawn(move || {
let mut num = counter.lock().unwrap();
*num += 1;
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
println!("Result: {}", *counter.lock().unwrap());
//the type implementing Send can be transferred between threads.
//std::marker
//it is safe for the type implementing Sync to be referenced from multiple threads
//Implementing Send and Sync Manually Is Unsafe
}
17. Object Oriented Programming Features of Rust
//lib.rs
pub mod gui {
pub trait Draw {
fn draw(&self);
}
//Definition of the Screen struct with a components field
//holding a vector of trait objects that implement the Draw trait
pub struct aScreen {
pub components: Vec<Box<dyn Draw>>,
}
impl aScreen {
pub fn run(&self) {
for component in self.components.iter() {
component.draw();
}
}
}
//restrict Screen has a same type list. ex Box<Button> Box<TextField>
pub struct Screen<T: Draw> {
pub components: Vec<T>,
}
impl<T> Screen<T>
where T: Draw {
pub fn run(&self) {
for component in self.components.iter() {
component.draw();
}
}
}
pub struct Button {
pub width: u32,
pub height: u32,
pub label: String,
}
impl Draw for Button {
fn draw(&self) {
println!("Drawed.");
}
}
}
//main.rs
//trait object
//object safe: 1.The return type isn’t Self.
//2.There are no generic type parameters. rust rfc 255
use oop::gui::Draw;
use oop::gui::{aScreen, Button};
struct SelectBox {
width: u32,
height: u32,
options: Vec<String>,
}
impl Draw for SelectBox {
fn draw(&self) {
println!("SelectBox.");
}
}
fn main() {
let screen = aScreen {
components: vec![
Box::new(SelectBox {
width: 75,
height: 10,
options: vec![
String::from("yes"),
String::from("Maybe"),
String::from("No"),
],
}),
Box::new(Button {
width: 50,
height: 10,
label: String::from("OK"),
}),
],
};
screen.run();
}
blog (state pattern)
//Object-Oriented Design Pattern (state pattern)
//允许对象在内部状态发生改变时改变它的行为，对象看起来好像修改了它的类)
/*
1. A blog post starts as an empty draft.
2. When the draft is done, a review of the post is requested.
3. When the post is approved, it gets published.
4. Only published blog posts return content to print,
so unapproved posts can’t accidentally be published.
*/
use blog::Post;
fn main() {
let mut post = Post::new();
post.add_text("I ate a salad for lunch today");
assert_eq!("", post.content());
post.request_review();
assert_eq!("", post.content());
post.approve();
assert_eq!("I ate a salad for lunch today", post.content());
}
//lib.rs
pub struct Post {
state: Option<Box<dyn State>>,
content: String,
}
impl Post {
pub fn new() -> Post {
Post {
state: Some(Box::new(Draft {})),
content: String::new(),
}
}
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
pub fn content(&self) -> &str {
self.state.as_ref().unwrap().content(&self)
}
pub fn request_review(&mut self) {
if let Some(s) = self.state.take() {
/*
take method to take the Some value out of the state field
and leave a None in its place
*/
self.state = Some(s.request_review())
}
}
pub fn approve(&mut self) {
if let Some(s) = self.state.take() {
self.state = Some(s.approve())
}
}
}
/*This syntax takes ownership of Box<Self>,
invalidating the old state so the state value of the Post
can transform into a new state.*/
trait State {
fn request_review(self: Box<Self>) -> Box<dyn State>;
fn approve(self: Box<Self>) -> Box<dyn State>;
fn content<'a>(&self, post: &'a Post) -> &'a str {
""
}
//the lifetime of the returned reference is related to the lifetime of the post argument
}
struct Draft {}
impl State for Draft {
fn request_review(self: Box<Self>) -> Box<dyn State> {
Box::new(PendingReview {})
}
fn approve(self: Box<Self>) -> Box<dyn State> {
self
}
}
struct PendingReview {}
/*
because when we request a review on a post
already in the PendingReview state,
it should stay in the PendingReview state.
*/
impl State for PendingReview {
fn request_review(self: Box<Self>) -> Box<dyn State> {
self
}
fn approve(self: Box<Self>) -> Box<dyn State> {
Box::new(Published {})
}
}
struct Published {}
impl State for Published {
fn request_review(self: Box<Self>) -> Box<dyn State> {
self
}
fn approve(self: Box<Self>) -> Box<dyn State> {
self
}
fn content<'a>(&self, post: &'a Post) -> &'a str {
&post.content
}
}
使用rust特性，效果相同实现.
use rust_blog::Post;
/*
Although you might be very familiar with object-oriented patterns,
rethinking the problem to take advantage of Rust’s features
can provide benefits, such as preventing some bugs at compile time.
Object-oriented patterns won’t always be the best solution in Rust
due to certain features, like ownership,
that object-oriented languages don’t have.
*/
fn main() {
let mut post = Post::new();
post.add_text("I ate a salad for lunch today");
let post = post.request_review();
let post = post.approve();
assert_eq!("I ate a salad for lunch today", post.content());
}
//lib.rs
pub struct Post {
content: String,
}
pub struct DraftPost {
content: String,
}
impl Post {
pub fn new() -> DraftPost {
DraftPost {
content: String::new(),
}
}
pub fn content(&self) -> &str {
&self.content
}
}
impl DraftPost {
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
pub fn request_review(self) -> PendingReviewPost {
PendingReviewPost {
content: self.content,
}
}
}
pub struct PendingReviewPost {
content: String,
}
impl PendingReviewPost {
pub fn approve(self) -> Post {
Post {
content: self.content,
}
}
}