在Rust中是否可以使用Rc自动化约束传播

简而言之，不是.

考虑一个简单的示例，其中两个域值由一条边连接:

A -> B

A包含一个指向B的Weak指针，它表示它们之间的边.我们希望删除A会导致删除B.然而，当我们将A的Weak指针升级为Rc时，现在有two个指向B的强引用.丢弃新获取的Rc只会使计数器减回1.

您所描述的级联效应只有在Rc以递归方式嵌套时才有效，比如在链表中.

struct Node {
    next: Rc<Node>,
}

这是因为你得到了一个调用堆栈，如:

 - Node::drop()          // Head of list dropped, which contained...
  - Rc::<Node>::drop()   // the only Rc pointing to...
   - Node::drop()        // the second element, which contained...
    - Rc::<Node>::drop() // the only Rc pointing to...
     - Node::drop()      // the third element, which...
      - etc.

对于任意的图形 struct ， node 通常位于平面存储中，如Vec<Rc<Node>>.在这种情况下，Node之一的drop实现将需要"到达"所有权层次 struct 以移除Vec的另一个元素.如果没有不安全的代码，这是不可能的，并且在很大程度上是Rust中的反模式.

请注意，其他一些语言(例如Java、C#)能够实现您想要的，因为它们具有垃圾收集、周期检测，最重要的是no concept of ownership.在这种语言中，如果您有指向某个对象的指针，则可以像拥有它一样对其进行修改，并在幕后处理细节(如存储位置和销毁时间).

在Rust中，图通常使用索引或ID而不是指针来实现.very个简单的有向图可能如下所示:

struct Node {
    num_incoming: usize,
    outgoing: Vec<usize>,
}

struct Graph {
    // Increment every time a node is added.
    next_id: usize,
    nodes: HashMap<usize, Node>,
}

然后，如您所述，删除 node 需要DFS/BFS，在本例中为BFS:

impl Graph {
    fn remove(&mut self, id: usize) {
        let removed = self.nodes.remove(&id).unwrap();
        
        // For simplicity, assume no incoming edges.
        assert_eq!(removed.num_incoming, 0);

        let mut queue = VecDeque::from_iter(removed.outgoing);

        while let Some(other) = queue.pop_front() {
            let Entry::Occupied(entry) = self.nodes.entry(other) else {
                panic!("missing node with id {id}");
            };

            // Decrement the refcount.
            entry.get_mut().num_incoming -= 1;

            // If the refcount hits zero, add all adjacent nodes to the queue
            // and remove the node.
            if entry.get().num_incoming == 0 {
                let node = entry.remove();
                queue.extend(node.outgoing);
            }
        }
    }
}

基于ID的图的更好的例子可以在petgraph crate中找到，它被广泛使用.