RustDay06------Exercise[71-80]

71.box的使用

说实话这题没太看懂.敲了个模板跟着提示就过了

// box1.rs
//
// At compile time, Rust needs to know how much space a type takes up. This
// becomes problematic for recursive types, where a value can have as part of
// itself another value of the same type. To get around the issue, we can use a
// `Box` - a smart pointer used to store data on the heap, which also allows us
// to wrap a recursive type.
//
// The recursive type we're implementing in this exercise is the `cons list` - a
// data structure frequently found in functional programming languages. Each
// item in a cons list contains two elements: the value of the current item and
// the next item. The last item is a value called `Nil`.
//
// Step 1: use a `Box` in the enum definition to make the code compile
// Step 2: create both empty and non-empty cons lists by replacing `todo!()`
//
// Note: the tests should not be changed
//
// Execute `rustlings hint box1` or use the `hint` watch subcommand for a hint.// I AM NOT DONE#[derive(PartialEq, Debug)]
pub enum List {Cons(i32, Box<List>),Nil,
}fn main() {println!("This is an empty cons list: {:?}", create_empty_list());println!("This is a non-empty cons list: {:?}",create_non_empty_list());
}pub fn create_empty_list() -> List {// todo!()List::Nil
}pub fn create_non_empty_list() -> List {// todo!()List::Cons(1, Box::new(List::Nil))
}#[cfg(test)]
mod tests {use super::*;#[test]fn test_create_empty_list() {assert_eq!(List::Nil, create_empty_list())}#[test]fn test_create_non_empty_list() {assert_ne!(create_empty_list(), create_non_empty_list())}
}

72.神奇的实例计数器

// rc1.rs
//
// In this exercise, we want to express the concept of multiple owners via the
// Rc<T> type. This is a model of our solar system - there is a Sun type and
// multiple Planets. The Planets take ownership of the sun, indicating that they
// revolve around the sun.
//
// Make this code compile by using the proper Rc primitives to express that the
// sun has multiple owners.
//
// Execute `rustlings hint rc1` or use the `hint` watch subcommand for a hint.// I AM NOT DONEuse std::rc::Rc;#[derive(Debug)]
struct Sun {}#[derive(Debug)]
enum Planet {Mercury(Rc<Sun>),Venus(Rc<Sun>),Earth(Rc<Sun>),Mars(Rc<Sun>),Jupiter(Rc<Sun>),Saturn(Rc<Sun>),Uranus(Rc<Sun>),Neptune(Rc<Sun>),
}impl Planet {fn details(&self) {println!("Hi from {:?}!", self)}
}fn main() {let sun = Rc::new(Sun {});println!("reference count = {}", Rc::strong_count(&sun)); // 1 referencelet mercury = Planet::Mercury(Rc::clone(&sun));println!("reference count = {}", Rc::strong_count(&sun)); // 2 referencesmercury.details();let venus = Planet::Venus(Rc::clone(&sun));println!("reference count = {}", Rc::strong_count(&sun)); // 3 referencesvenus.details();let earth = Planet::Earth(Rc::clone(&sun));println!("reference count = {}", Rc::strong_count(&sun)); // 4 referencesearth.details();let mars = Planet::Mars(Rc::clone(&sun));println!("reference count = {}", Rc::strong_count(&sun)); // 5 referencesmars.details();let jupiter = Planet::Jupiter(Rc::clone(&sun));println!("reference count = {}", Rc::strong_count(&sun)); // 6 referencesjupiter.details();// 从这里开始混入了奇怪的东西// TODOlet saturn = Planet::Saturn(Rc::clone(&sun));// Planet::Saturn(Rc::new(Sun {}));println!("reference count = {}", Rc::strong_count(&sun)); // 7 referencessaturn.details();// TODOlet uranus = Planet::Uranus(Rc::clone(&sun));// (Rc::new(Sun {}));println!("reference count = {}", Rc::strong_count(&sun)); // 8 referencesuranus.details();// TODOlet neptune = Planet::Neptune(Rc::clone(&sun));// (Rc::new(Sun {}));println!("reference count = {}", Rc::strong_count(&sun)); // 9 referencesneptune.details();assert_eq!(Rc::strong_count(&sun), 9);// 从这里开始下降drop(neptune);println!("reference count = {}", Rc::strong_count(&sun)); // 8 referencesdrop(uranus);println!("reference count = {}", Rc::strong_count(&sun)); // 7 referencesdrop(saturn);println!("reference count = {}", Rc::strong_count(&sun)); // 6 referencesdrop(jupiter);println!("reference count = {}", Rc::strong_count(&sun)); // 5 referencesdrop(mars);println!("reference count = {}", Rc::strong_count(&sun)); // 4 references// TODOdrop(earth);println!("reference count = {}", Rc::strong_count(&sun)); // 3 references// TODOdrop(venus);println!("reference count = {}", Rc::strong_count(&sun)); // 2 references// TODOdrop(mercury);println!("reference count = {}", Rc::strong_count(&sun)); // 1 referenceassert_eq!(Rc::strong_count(&sun), 1);
}

73.使用Arc创建共享变量

// arc1.rs
//
// In this exercise, we are given a Vec of u32 called "numbers" with values
// ranging from 0 to 99 -- [ 0, 1, 2, ..., 98, 99 ] We would like to use this
// set of numbers within 8 different threads simultaneously. Each thread is
// going to get the sum of every eighth value, with an offset.
//
// The first thread (offset 0), will sum 0, 8, 16, ...
// The second thread (offset 1), will sum 1, 9, 17, ...
// The third thread (offset 2), will sum 2, 10, 18, ...
// ...
// The eighth thread (offset 7), will sum 7, 15, 23, ...
//
// Because we are using threads, our values need to be thread-safe.  Therefore,
// we are using Arc.  We need to make a change in each of the two TODOs.
//
// Make this code compile by filling in a value for `shared_numbers` where the
// first TODO comment is, and create an initial binding for `child_numbers`
// where the second TODO comment is. Try not to create any copies of the
// `numbers` Vec!
//
// Execute `rustlings hint arc1` or use the `hint` watch subcommand for a hint.// I AM NOT DONE#![forbid(unused_imports)] // Do not change this, (or the next) line.
use std::sync::Arc;
use std::thread;fn main() {let numbers: Vec<_> = (0..100u32).collect();let shared_numbers = Arc::new(numbers);// TODOlet mut joinhandles = Vec::new();for offset in 0..8 {let child_numbers = shared_numbers.clone();// TODOjoinhandles.push(thread::spawn(move || {let sum: u32 = child_numbers.iter().filter(|&&n| n % 8 == offset).sum();println!("Sum of offset {} is {}", offset, sum);}));}for handle in joinhandles.into_iter() {handle.join().unwrap();}
}

74.使用cow检测变量的所有权是否发生移动

很抽象这个没看懂

// cow1.rs
//
// This exercise explores the Cow, or Clone-On-Write type. Cow is a
// clone-on-write smart pointer. It can enclose and provide immutable access to
// borrowed data, and clone the data lazily when mutation or ownership is
// required. The type is designed to work with general borrowed data via the
// Borrow trait.
//
// This exercise is meant to show you what to expect when passing data to Cow.
// Fix the unit tests by checking for Cow::Owned(_) and Cow::Borrowed(_) at the
// TODO markers.
//
// Execute `rustlings hint cow1` or use the `hint` watch subcommand for a hint.// I AM NOT DONEuse std::borrow::Cow;fn abs_all<'a, 'b>(input: &'a mut Cow<'b, [i32]>) -> &'a mut Cow<'b, [i32]> {for i in 0..input.len() {let v = input[i];if v < 0 {// Clones into a vector if not already owned.input.to_mut()[i] = -v;}}input
}#[cfg(test)]
mod tests {use super::*;#[test]fn reference_mutation() -> Result<(), &'static str> {// Clone occurs because `input` needs to be mutated.let slice = [-1, 0, 1];let mut input = Cow::from(&slice[..]);match abs_all(&mut input) {Cow::Owned(_) => Ok(()),_ => Err("Expected owned value"),}}#[test]fn reference_no_mutation() -> Result<(), &'static str> {// No clone occurs because `input` doesn't need to be mutated.let slice = [0, 1, 2];let mut input = Cow::from(&slice[..]);match abs_all(&mut input) {// TODOCow::Borrowed(_) => Ok(()),_ => Err("Expected borrowed value"),}}#[test]fn owned_no_mutation() -> Result<(), &'static str> {// We can also pass `slice` without `&` so Cow owns it directly. In this// case no mutation occurs and thus also no clone, but the result is// still owned because it was never borrowed or mutated.let slice = vec![0, 1, 2];let mut input = Cow::from(slice);match abs_all(&mut input) {// TODOCow::Owned(_) => Ok(()),_ => Err("Expected owned value"),}}#[test]fn owned_mutation() -> Result<(), &'static str> {// Of course this is also the case if a mutation does occur. In this// case the call to `to_mut()` returns a reference to the same data as// before.let slice = vec![-1, 0, 1];let mut input = Cow::from(slice);match abs_all(&mut input) {// TODOCow::Owned(_) => Ok(()),_ => Err("Expected owned value"),}}
}

75.等待线程

使用join()方法即可

// threads1.rs
//
// This program spawns multiple threads that each run for at least 250ms, and
// each thread returns how much time they took to complete. The program should
// wait until all the spawned threads have finished and should collect their
// return values into a vector.
//
// Execute `rustlings hint threads1` or use the `hint` watch subcommand for a
// hint.// I AM  DONEuse std::thread;
use std::time::{Duration, Instant};fn main() {let mut handles = vec![];for i in 0..10 {handles.push(thread::spawn(move || {let start = Instant::now();thread::sleep(Duration::from_millis(250));println!("thread {} is complete", i);start.elapsed().as_millis()}));}let mut results: Vec<u128> = vec![];for handle in handles {// TODO: a struct is returned from thread::spawn, can you use it?results.push(handle.join().unwrap())}if results.len() != 10 {panic!("Oh no! All the spawned threads did not finish!");}println!();for (i, result) in results.into_iter().enumerate() {println!("thread {} took {}ms", i, result);}
}

76.给共享变量加上互斥锁

// threads2.rs
//
// Building on the last exercise, we want all of the threads to complete their
// work but this time the spawned threads need to be in charge of updating a
// shared value: JobStatus.jobs_completed
//
// Execute `rustlings hint threads2` or use the `hint` watch subcommand for a
// hint.// I AM NOT DONEuse std::sync::Arc;
use std::sync::Mutex;
use std::thread;
use std::time::Duration;struct JobStatus {jobs_completed: u32,
}fn main() {let status = Arc::new(Mutex::new(JobStatus { jobs_completed: 0 }));let mut handles = vec![];for _ in 0..10 {let status_shared = Arc::clone(&status);let handle = thread::spawn(move || {thread::sleep(Duration::from_millis(250));// TODO: You must take an action before you update a shared valuestatus_shared.lock().unwrap().jobs_completed += 1;});handles.push(handle);}for handle in handles {handle.join().unwrap();// TODO: Print the value of the JobStatus.jobs_completed. Did you notice// anything interesting in the output? Do you have to 'join' on all the// handles?// println!("jobs completed {}", ???);}
}

77.要开起多个线程,需要使用不同的实例?

// threads3.rs
//
// Execute `rustlings hint threads3` or use the `hint` watch subcommand for a
// hint.// I AM NOT DONEuse std::sync::mpsc;
use std::sync::Arc;
use std::thread;
use std::time::Duration;struct Queue {length: u32,first_half: Vec<u32>,second_half: Vec<u32>,
}impl Queue {fn new() -> Self {Queue {length: 10,first_half: vec![1, 2, 3, 4, 5],second_half: vec![6, 7, 8, 9, 10],}}
}fn send_tx(q: Queue, tx: mpsc::Sender<u32>) -> () {let qc = Arc::new(q);let qc1 = Arc::clone(&qc);let qc2 = Arc::clone(&qc);let tx1 = tx.clone();let tx2 = tx.clone();thread::spawn(move || {for val in &qc1.first_half {println!("sending {:?}", val);tx1.send(*val).unwrap();thread::sleep(Duration::from_secs(1));}});thread::spawn(move || {for val in &qc2.second_half {println!("sending {:?}", val);tx2.send(*val).unwrap();thread::sleep(Duration::from_secs(1));}});
}fn main() {let (tx, rx) = mpsc::channel();let queue = Queue::new();let queue_length = queue.length;send_tx(queue, tx);let mut total_received: u32 = 0;for received in rx {println!("Got: {}", received);total_received += 1;}println!("total numbers received: {}", total_received);assert_eq!(total_received, queue_length)
}

78.宏函数的调用

需要加上!

// macros1.rs
//
// Execute `rustlings hint macros1` or use the `hint` watch subcommand for a
// hint.// I AM NOT DONEmacro_rules! my_macro {() => {println!("Check out my macro!");};
}fn main() {my_macro!();
}

79.宏需要在调用前声明,而不是调用后

// macros2.rs
//
// Execute `rustlings hint macros2` or use the `hint` watch subcommand for a
// hint.// I AM  DONE
macro_rules! my_macro {() => {println!("Check out my macro!");};
}
fn main() {my_macro!();
}//old my_macro place

80.使用#[macro_use]属性暴露mod里面的宏函数

// macros3.rs
//
// Make me compile, without taking the macro out of the module!
//
// Execute `rustlings hint macros3` or use the `hint` watch subcommand for a
// hint.// I AM NOT DONE
#[macro_use]
mod macros {macro_rules! my_macro {() => {println!("Check out my macro!");};}
}fn main() {my_macro!();
}