Time：2021-10-17

# Explanation content

1. Consider needs

B and C share the ownership of A. how to realize it
Example 1: using box implementation

``````enum List {
Cons(i32, Box<List>),
Nil,
}
use crate::List::{Cons, Nil};
fn main() {
let a = Cons(5,
Box::new(Cons(10,
Box::new(Nil))));
let b = Cons(3, Box::new(a));
let c = Cons(4, Box::new(a));
}``````

This implementation reports an error. The prompt has been moved.

Example 2: implementation using RC

``````enum List {
Cons(i32, Rc<List>),
Nil,
}
use crate::List::{Cons, Nil};
use std::rc::Rc;
fn main() {
let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
let b = Cons(3, Rc::clone(&a));   // It is also OK to use A. clone () here
let c = Cons(4, Rc::clone(&a));
}``````

2. Cloning RC increases the reference count

``````fn main() {
let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
println!("count after creating a = {}", Rc::strong_count(&a));
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));
}``````

Through RC:: strong_ The count function prints the reference count divided by.

3. RC allows read-only data sharing between multiple parts of the program, because multiple variable references in the same location may cause data competition and inconsistency.