rust语言基础学习: 使用智能指针Rc<T>让值可以有多个所有者

 1#[derive(Debug)]
 2struct Employee {
 3    name: String,
 4}
 5
 6#[derive(Debug)]
 7struct Company {
 8    name: String,
 9    manager: Employee,
10}
11
12
13
14fn main() {
15    let employee = Employee {
16        name: String::from("张三"),
17    };
18  
19    let company1 = Company {
20        name: String::from("分公司1"),
21        manager: employee, // value moved here
22    };
23    let company2 = Company {
24        name: String::from("分公司2"),
25        manager: employee, // value used here after move
26    };
27   
28    println!("{:?}, {:?}", company1, company2);
29}

 1#[derive(Debug)]
 2struct Employee {
 3    name: String,
 4}
 5
 6#[derive(Debug)]
 7struct Company<'a> {
 8    name: String,
 9    manager: &'a Employee,
10}
11
12
13
14fn main() {
15    let employee = &Employee {
16        name: String::from("张三"),
17    };
18  
19    let company1 = Company {
20        name: String::from("分公司1"),
21        manager: employee,
22    };
23    let company2 = Company {
24        name: String::from("分公司2"),
25        manager: employee,
26    };
27   
28    println!("{:?}, {:?}", company1, company2);
29}

 1use std::rc::Rc;
 2
 3fn main() {
 4    let num = Rc::new(5);
 5    println!("{}", Rc::strong_count(&num)); // 1
 6    let num1 = num.clone();
 7    {
 8        println!("{}", Rc::strong_count(&num1)); // 2
 9        let num2 = num.clone();
10        println!("{}", Rc::strong_count(&num2)); // 3
11    }
12    println!("{}", Rc::strong_count(&num)); // 2
13}

 1#[stable(feature = "rust1", since = "1.0.0")]
 2impl<T: ?Sized> Clone for Rc<T> {
 3    /// Makes a clone of the `Rc` pointer.
 4    ///
 5    /// This creates another pointer to the same allocation, increasing the
 6    /// strong reference count.
 7    ///
 8    /// # Examples
 9    ///
10    /// ```
11    /// use std::rc::Rc;
12    ///
13    /// let five = Rc::new(5);
14    ///
15    /// let _ = Rc::clone(&five);
16    /// ```
17    #[inline]
18    fn clone(&self) -> Rc<T> {
19        self.inner().inc_strong();
20        Self::from_inner(self.ptr)
21    }
22}

 1 #[cfg(not(no_global_oom_handling))]
 2    #[stable(feature = "rust1", since = "1.0.0")]
 3    pub fn new(value: T) -> Rc<T> {
 4        // There is an implicit weak pointer owned by all the strong
 5        // pointers, which ensures that the weak destructor never frees
 6        // the allocation while the strong destructor is running, even
 7        // if the weak pointer is stored inside the strong one.
 8        Self::from_inner(
 9            Box::leak(box RcBox { strong: Cell::new(1), weak: Cell::new(1), value }).into(),
10        )
11    }

 1
 2#[derive(Debug)]
 3struct Employee {
 4    name: String,
 5}
 6
 7#[derive(Debug)]
 8struct Company {
 9    name: String,
10    manager: Rc<Employee>,
11}
12
13
14
15use std::rc::Rc;
16
17fn main() {
18    let employee = Rc::new(Employee {
19        name: String::from("张三"),
20    });
21  
22    let company1 = Company {
23        name: String::from("分公司1"),
24        manager: employee.clone(),
25    };
26    let company2 = Company {
27        name: String::from("分公司2"),
28        manager: employee,
29    };
30   
31    println!("{:?}, {:?}", company1, company2);
32  
33
34}