# use genrc::rc::{Rc, RcBox, Weak};

    // construct the object initially uninitialized
    let mut obj : RcBox<Option<i32>> = Rc::new_unique(None);

    // ... later ...
    // initialize the object
    obj.replace(5);

    // project to the inner value that we just created
    let obj : Rc<i32> = RcBox::project(obj, |x| x.as_ref().unwrap());

    assert_eq!(*obj, 5);

您还可以创建循环数据结构，而不需要使用 RefCell 或 new_cyclic

    use genrc::rc::{Rc, RcBox, Weak};
    struct Node {
        edges: Vec<Weak<Node>>,
    }

    // Make a graph
    let mut graph: Vec<RcBox<Node>> = (0..5).map(|_| {
        Rc::new_unique(Node { edges: vec![] })
    }).collect();

    // Make some random edges in the graph
    for i in 0..5 {
        for d in 1..3 {
            let j = (i + d) % 5;

            let link = RcBox::downgrade(&graph[j]);
            graph[i].edges.push(link);
        }
    }

    // we still have unique handles on the nodes, so attempting to upgrade
    // weak pointers will fail.
    let p = graph[1].edges[0].clone();
    assert!(p.upgrade().is_none());

    // convert `RcBox` to a normal `Rc` with `into()`.
    let graph: Vec<Rc<Node>> = graph.into_iter().map(Into::into).collect();

    // now the weak pointers are valid - we've made a graph with (weak)
    // cycles, no unsafe or internal mutation required.
    assert!(Rc::ptr_eq(&graph[0].edges[1].upgrade().unwrap(), &graph[2]));

静态数据

与 std 不同，引用可以指向静态数据而不需要复制，这同样是通过使用 project() 实现的。

    # use genrc::rc::Rc;
    static BIGBUF: [u8; 1024] = [1; 1024];

    let p: Rc<()> = Rc::new(());
    let p: Rc<[u8]> = Rc::project(p, |_| &BIGBUF[..]);

    assert!(std::ptr::eq(&BIGBUF[..], &*p));

因此，您可以使用 Rc 来跟踪可能拥有的、可能静态的数据，类似于 Cow。

其他内容

夜间Rust allocator_api 支持

allocator_api 功能启用了不稳定分配器API，允许 Rc 和 Arc 使用自定义分配器。

Rc::new_in 返回一个类型为 Rc<T, A> 的 Rc，其中分配器是类型的一部分。如果需要，您可以使用 Rc::erase_allocator() 来隐藏分配器。

生命周期

有些令人惊讶的是，std::rc::Rc 允许您创建一个指向局部变量的 Rc。例如，这是合法的

    use std::{cell::Cell, rc::Rc};
    let x = Cell::new(1);
    let y : Rc<&Cell<i32>> = Rc::new(&x);
    x.set(2);
    assert_eq!(y.get(), 2);

这种 Rc 的类型是 Rc<&'a T>，其中 'a 是被引用者的生命周期，因此 Rc 不能比被引用者存活更长时间。

    use genrc::rc::Rcl;

    // Imagine we have some JSON data that we loaded from a file
    // (or data allocated in an arena, etc)
    let bigdata : Vec<u8> = b"Not really json, use your imagination".to_vec();

    // buf points directly into `bigdata`, not a copy
    let buf : Rcl<[u8]> = Rcl::from_ref(&bigdata[..]);
    assert!(std::ptr::eq(&*buf, &bigdata[..]));

    let word : Rcl<[u8]> = Rcl::project(buf, |x| &x[4..10]);
    assert!(std::ptr::eq(&*word, &bigdata[4..10]));

    use genrc::rc::Rcl;

    // Token in a parser where the buffer is an `Rc<str>`, and `text` can point
    // directly into the buffer. (Or `text` can point to owned data, e.g. for
    // unescaped strings, and callers generally don't have to care.)
    struct Token<'a> {
      some_data: u32,
      text: Rcl<'a, str>
    }

    # use genrc::rc::{Rc, RcBox, Weak};
    // construct the object uninitialized
    let mut obj : RcBox<Option<i32>> = Rc::new_unique(None);

    // ... later ...
    // initialize the object
    obj.replace(5);

    // project to the inner value that we just created
    let obj : Rc<i32> = RcBox::project(obj, |x| x.as_ref().unwrap());

    assert_eq!(*obj, 5);