RefCell::as_ptr地址是否稳定？含Rc<RefCell>的结构体如何实现Hash？

核心结论 #

直接用Rc<RefCell<Node>>作为哈希键即可——Rc<T>默认的Hash实现就是基于其指向的堆对象指针，完全满足「唯一、稳定标识节点身份」的需求，相当于Ruby里的object_id。

关于指针稳定性的疑问 #

Rc<T>::as_ptr()返回的指针在对象生命周期内绝对稳定：

• Rc的语义是共享所有权，堆上的对象只会在引用计数归零时被销毁，在此之前不会被移动、重新分配内存。
• 你拿到的Rc<RefCell<Node>>指向的堆内存地址，从创建到销毁全程不变，完全可以当作节点的唯一身份标识。

为什么不用RefCell的内容哈希？ #

你提到的「借用RefCell::borrow哈希内容」方案不可靠，原因有两点：

1. 链表节点的内容可能变化，哈希值会随之改变，破坏哈希表的一致性；
2. 若存在并发借用（哪怕是单线程里的重入借用），会直接触发panic，程序崩溃。

而我们解决「复制带随机指针的链表」问题时，需要的是节点的身份映射，不是内容映射，所以基于指针的哈希才是正确方向。

具体实现代码示例 #

以LeetCode的问题场景为例，直接用HashMap<Rc<RefCell<Node>>, Rc<RefCell<Node>>>建立原节点到复制节点的映射：

use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;

#[derive(Debug, Clone)]
struct Node {
    val: i32,
    next: Option<Rc<RefCell<Node>>>,
    random: Option<Rc<RefCell<Node>>>,
}

impl Node {
    fn new(val: i32) -> Self {
        Node { val, next: None, random: None }
    }
}

fn copy_random_list(head: Option<Rc<RefCell<Node>>>) -> Option<Rc<RefCell<Node>>> {
    let mut node_map = HashMap::new();
    let mut current = head.clone();

    // 第一遍：复制所有节点，建立原节点到新节点的映射
    while let Some(node) = current {
        let new_node = Rc::new(RefCell::new(Node::new(node.borrow().val)));
        node_map.insert(node.clone(), new_node);
        current = node.borrow().next.clone();
    }

    // 第二遍：复制next和random指针
    let mut current = head;
    while let Some(node) = current {
        let new_node = node_map.get(&node).unwrap().clone();
        let mut new_node_mut = new_node.borrow_mut();
        
        // 映射next指针
        new_node_mut.next = node.borrow().next.as_ref()
            .map(|original_next| node_map.get(original_next).unwrap().clone());
        // 映射random指针
        new_node_mut.random = node.borrow().random.as_ref()
            .map(|original_random| node_map.get(original_random).unwrap().clone());
        
        current = node.borrow().next.clone();
    }

    head.as_ref().map(|original_head| node_map.get(original_head).unwrap().clone())
}

补充：手动实现Hash的场景 #

如果确实需要为Node结构体手动实现Hash（比如直接用Node实例作为键），可以基于节点自身的内存地址哈希：

use std::hash::{Hash, Hasher};

impl Hash for Node {
    fn hash<H: Hasher>(&self, state: &mut H) {
        // 用当前Node实例的内存地址作为哈希依据
        (&*self as *const Node).hash(state);
    }
}

但注意，这种场景下你需要确保Node实例始终在堆上（比如被Rc/Box包裹），否则栈上的Node地址会随栈帧变化而失效。

内容的提问来源于stack exchange，提问作者De Cay