Rc

Rc is a reference-counted shared pointer. Use this when you need to refer to the same data from multiple places:

  1. use std::rc::Rc;
  3. fn main() {
  4.     let mut a = Rc::new(10);
  5.     let mut b = a.clone();
  7.     println!("a: {a}");
  8.     println!("b: {b}");
  9. }
  • If you need to mutate the data inside an Rc, you will need to wrap the data in a type such as Cell or RefCell.
  • See Arc if you are in a multi-threaded context.

  • You can downgrade a shared pointer into a Weak pointer to create cycles that will get dropped.

  • Like C++’s std::shared_ptr.

  • clone is cheap: creates a pointer to the same allocation and increases the reference count.
  • make_mut actually clones the inner value if necessary (“clone-on-write”) and returns a mutable reference.
  • You can downgrade() a Rc into a weakly reference-counted object to create cycles that will be dropped properly (likely in combination with RefCell).
  1. use std::rc::{Rc, Weak};
  2. use std::cell::RefCell;
  4. #[derive(Debug)]
  5. struct Node {
  6.     value: i64,
  7.     parent: Option<Weak<RefCell<Node>>>,
  8.     children: Vec<Rc<RefCell<Node>>>,
  9. }
  11. fn main() {
  12.     let mut root = Rc::new(RefCell::new(Node {
  13.         value: 42,
  14.         parent: None,
  15.         children: vec![],
  16.     }));
  17.     let child = Rc::new(RefCell::new(Node {
  18.         value: 43,
  19.         children: vec![],
  20.         parent: Some(Rc::downgrade(&root))
  21.     }));
  22.     root.borrow_mut().children.push(child);
  24.     println!("graph: {root:#?}");
  25. }