advance/circle-self-ref/circle-reference

[giscus[bot]]

advance/circle-self-ref/circle-reference

https://course.rs/advance/circle-self-ref/circle-reference.html

[leowei1234567]

First Blood

[lonexw]

要扎实这块的知识，还是要尝试手写简单的 链表和树结构的实现，不能光看不练。

[guanguoliang]

请问有没有大佬可以通过Option<Rc<RefCell>>来实现一个双向读的链表，目前在pre往回读的时候，没办法从里面读出数据，实在很难受，希望能有大佬可以给点思路

[tjw123hh]

应该可以

//in src/lib.rs

use std::cell::RefCell;
use std::fmt::Display;
use std::rc::{Rc, Weak};

#[derive(Clone)]
struct List<T: Clone> {
    prev: Weak<RefCell<Self>>,
    value: RefCell<T>,
    next: Option<Rc<RefCell<Self>>>,
}

#[derive(Clone)]
pub struct DoubleLinkedList<T: Clone>(Rc<RefCell<List<T>>>);

impl<T: Clone> DoubleLinkedList<T> {
    pub fn new(value: T) -> Self {
        DoubleLinkedList(Rc::new(RefCell::new(List {
            prev: Weak::new(),
            value: RefCell::new(value),
            next: None,
        })))
    }
    pub fn set_next(&mut self, next: Self) {
        self.0.borrow_mut().next = Some(next.0.clone());
        next.0.borrow_mut().prev = Rc::downgrade(&self.0)
    }
    pub fn append(&mut self, value: T) {
        let next = Self::new(value);
        self.set_next(next);
    }
    pub fn prev(&self) -> Option<Self> {
        self.0.borrow().prev.upgrade().map(|rc_ref| Self(rc_ref))
    }
    pub fn next(&self) -> Option<Self> {
        self.0.borrow().next.clone().map(|rc_ref| Self(rc_ref))
    }
    pub fn head(&self) -> Self {
        if let Some(prev) = self.prev() {
            prev.head()
        } else {
            self.clone()
        }
    }
    pub fn tail(&self) -> Self {
        if let Some(next) = self.next() {
            next.tail()
        } else {
            self.clone()
        }
    }
    pub fn value(&self) -> RefCell<T> {
        self.0.borrow().value.clone()
    }
    pub fn set_value(&mut self, value: T) {
        self.0.borrow_mut().value = RefCell::new(value);
    }
}

impl<T: Clone + Display> Display for DoubleLinkedList<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "DoubleLinkedList[")?;
        let item = self.head();
        write!(f, "{}", item.value().borrow())?;
        let mut element = self.next();
        while let Some(item) = element {
            write!(f, ", ")?;
            write!(f, "{}", item.value().borrow())?;
            element = item.next()
        }
        write!(f, "]")
    }
}

[noo-have]

仔细想想，Rc和Weak和js的引用计数机制以及WeakMap/WeakSet好像一模一样哈哈

[cctga]

Java：我也是

[cbbb8533]

let strong_five: Option<Rc<_>> = weak_five.upgrade();
assert_eq!(*strong_five.unwrap(), 5);

哪位大神解释一下？
1、strong_five是Option<Rc<_>>，它怎么能和数字5进行比较？
2、strong_five.unwrap()中的解引用号为什么需要存在？

[Saltedf]

strong_five并没有和5直接比较.
unwrap() "脱去"了Option<>, 而*取出了Rc<>指向的数字.
星号 是为了让两个数字类型的值进行比较, 而不是 Rc<{integer}> 和 {integer}

支撑着自动解引用的 Deref 的文档中有这么一段

If T implements Deref<Target = U>, and x is a value of type T, then:

• In immutable contexts, *x (where T is neither a reference nor a raw pointer)
  is equivalent to *Deref::deref(&x).
• Values of type &T are coerced to values of type &U
• T implicitly implements all the (immutable) methods of the type U.

而 assert_eq!() 展开相当于 :

    let a = Rc::new(123);
    let b = 123;
    
    match (&a, &b) {
        (l,r) => if !(*l == *r) {  //  <<== ERROR!! 
            panic!();
        }
    }

[YtxErp]

为什么去掉*strong_five.unwrap() 结果就都 是Some(5)了啊？？

use std::rc::Rc;

fn main() {
    let five = Rc::new(5);
    let weak_five = Rc::downgrade(&five);
    let strong_five = weak_five.upgrade();
    println!("{:?}", strong_five);

    drop(five);
    let strong_five = weak_five.upgrade();
    println!("{:?}", strong_five);
}

[YtxErp]

查了unwrap()明白了，five在weak_five.upgrade()后引用计数为2，strong_five.unwrap()消耗一个计数，drop消耗一个，5已被丢弃

[greyhawk]

这里，List 为啥是 RefCell<Rc>，而不是 Rc<RefCell> 呢？

[greyhawk]

多个值指向一个内部可变的 List，我感觉应该是 Rc<RefCell> 类型呢？

[limon]

a 里面 Rc 先指向 Nil，b 生成之后才能指向 b，所以这里需要 RefCell 提供一个内部可变性修改这个 Rc
变的是要指向哪个 List
而不是所指的那个 List

[MintWind233]

为啥第一个例子的一对多关系用Weak指针
···
gadgets: RefCell::new(Vec::new()),
···

但是第二个例子的一对多关系反而是RefCell<Vec<Rc<Node>>>
而一对一是Weak指针 RefCell<Weak<Node>>

Weak指针应该在什么地方使用，是以关系决定，还是都可以？只要这种双向引用关系不出现循环引用就行了

[Zolyn]

把第一个例子改成第二个那样也是可以编译通过的，我能想到的区别就是数据销毁的时机不同。至于第一个例子为什么这样写我也不是很懂

[mengxuan37]

看起来rust这些特性是在为自己的设计填坑，实际使用价值有没有

[Scott169]

这些智能指针用来写某些业务逻辑应该用得上，要是基本数据结构真不如用裸指针写。看了下源码链接的二叉树unsafe版源码，就像是从C翻译过来一样，非常好读易懂

[BruceChar]

tree那个例子为什么用ReCell<Rc<>> 而不是 Rc<RefCell<>>

[wupeaking]

我现在的做法是， 如果你需要动态的修改结构体的这个字段的值， 那么你应该把这个值最先用Refcell定义， 然后再进一步考虑，这个值其他的特性。比如他可能是空的， 那我要用option包一下， 在遍历过程中需要临时变量去引用它， 那我就用Rc/Weak包一下。 直到满足最终的条件。

[wupeaking]

断断续续用时了一个月看到这一章， 在编译器的各种暴击之后，终于能够自己独立的写出链表和二叉树了。 快哭了都！

[sunface]

牛逼了！

[Linuxdazhao]

为什么 a.tail() 会导致循环调用呢？不就是一个match 函数吗？

[Linuxdazhao]

在介绍println 导致循环调用的，建议说明一下为什么会出现循环调用。新手看的很懵逼，搞了很久才明白，是debug derive 导致的

[yuhao00]

trpl上的tail()是真的递归找最后一个节点，这里的tail()名不副实。

[vince-1998]

因为在 Debug trait 的默认实现中，Rust 假设结构体的所有字段也都实现了 Debug trait，然后尝试递归地打印每个字段的内容

[qianyiwangmeng]

parent没有了，是不是leaf也没了存在的必要？

[lihongtao1024]

只能说干得漂亮。

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

#[derive(Debug)]
enum List<T> {
    Elem(T, RefCell<Rc<List<T>>>),
    None,
}

impl<T> List<T> {
    fn new(t: T) -> Rc<Self> {
        Rc::new(Self::Elem(t, RefCell::new(Rc::new(List::None))))
    }

    fn set_next(&self, list: &Rc<List<T>>) -> Option<&RefCell<Rc<List<T>>>> {
        match self {
            List::Elem(_, next) => {
                *next.borrow_mut() = list.clone();
                Some(next)
            },
            _ => None,
        }
    }
}

fn main() {
    let a = List::new("a");
    let b = List::new("b");
    println!("a.count = {}, b.count = {}", Rc::strong_count(&a), Rc::strong_count(&b));

    b.set_next(&a);
    a.set_next(&b);
    println!("a.count = {}, b.count = {}", Rc::strong_count(&a), Rc::strong_count(&b));

    println!("a = {:?}", a);
}

[lihongtao1024]

使用weak。

use std::cell::RefCell;
use std::rc::Rc;
use std::rc::Weak;

#[derive(Debug)]
enum List<T> {
    Elem(T, RefCell<Weak<List<T>>>),
    None,
}

impl<T> List<T> {
    fn new(t: T) -> Rc<Self> {
        Rc::new(Self::Elem(t, RefCell::new(Weak::new())))
    }

    fn set_next(&self, list: &Rc<List<T>>) -> Option<&RefCell<Weak<List<T>>>> {
        match self {
            List::Elem(_, next) => {
                *next.borrow_mut() = Rc::downgrade(list);
                Some(next)
            },
            _ => None,
        }
    }
}

fn main() {
    let a = List::new("a");
    let b = List::new("b");
    println!("a.count = {}, b.count = {}", Rc::strong_count(&a), Rc::strong_count(&b));

    b.set_next(&a);
    a.set_next(&b);
    println!("a.count = {}, b.count = {}", Rc::strong_count(&a), Rc::strong_count(&b));

    println!("a = {:?}", a);
}

[lihongtao1024]

尝试着用这章的知识写了一个tree，并实现广度优先编历。不知道有没有办法把迭代器改为使用引用，从weak.borrow里借用出来的是一个临时引用，我没办法在迭借器里持有它。

use std::cell::RefCell;
use std::collections::linked_list::LinkedList;
use std::fmt::Debug;
use std::rc::Rc;
use std::rc::Weak;

#[derive(Debug)]
struct Node<T: Debug> {
    value: T,
    parent: RefCell<Weak<Node<T>>>,
    children: RefCell<Vec<Rc<Node<T>>>>,
}

#[derive(Debug)]
struct NodeIterator<T: Debug> {
    nodes: LinkedList<Rc<Node<T>>>,
}

impl<T: Debug> Node<T> {
    fn new(value: T) -> Rc<Self> {
        Rc::new(
            Self {
                value,
                parent: RefCell::new(Weak::new()),
                children: RefCell::new(Vec::new()),
            }
        )
    }

    fn add_child(self: &Rc<Self>, child: Rc<Node<T>>) {
        *child.parent.borrow_mut() = Rc::downgrade(self);
        self.children.borrow_mut().push(child);
    }

    fn iter(self: &Rc<Self>) -> NodeIterator<T> {
        let mut nodes = LinkedList::new();
        nodes.push_front(self.clone());

        NodeIterator { nodes }
    }
}

impl<T: Debug> Drop for Node<T> {
    fn drop(&mut self) {
        while let Some(_node) = self.children.borrow_mut().pop() {}
    }
}

impl<T: Debug> Iterator for NodeIterator<T> {
    type Item = Rc<Node<T>>;

    fn next(&mut self) -> Option<Self::Item> {
        match self.nodes.pop_back() {
            Some(node) => {
                node.children
                    .borrow()
                    .iter()
                    .all(|node| {
                        self.nodes.push_front(node.clone());
                        true
                    });
                Some(node)
            },
            _ => None,
        }

    }
}

fn main() {
    let n1 = Node::new(1);

    let n11 = Node::new(11);
    n11.add_child(Node::new(111));

    let n12 = Node::new(12);
    let n121 = Node::new(121);
    n121.add_child(Node::new(1211));
    n12.add_child(n121);
    n12.add_child(Node::new(122));

    let n13 = Node::new(13);
    n13.add_child(Node::new(131));
    let n132 = Node::new(132);
    n132.add_child(Node::new(1321));
    n13.add_child(n132);
    let n133 = Node::new(133);
    n133.add_child(Node::new(1331));
    n133.add_child(Node::new(1332));
    n133.add_child(Node::new(1333));
    n13.add_child(n133);

    n1.add_child(n11);
    n1.add_child(n12);
    n1.add_child(n13);

    println!("root = {:?}\r\n\r\n", n1);

    for node in n1.iter() {
        println!("node = {:?}", node.value);
    }
}

[hulyhulyhuly]

自己试着用into_iter改, 有点小错误QQ
这是Bito AI 提供的改善方向
但我不确定效能是否更好或更差

Some(node) => {
    let children = node.children.replace(Vec::new());
    for child in children.into_iter().rev() {
        self.nodes.push_front(child);
    }
    Some(node)
}

[hulyhulyhuly]

检查得不够仔细 ".rev()"是多余的

[17998384]

然而你缺少了关键的remove

[TsGanT]

不知道我的理解对不对，所以使用weak可以防止出现循环引用并导致stack overflow的主要原因是 weak不会自动deref，所以他不会无限的被互相调用下去？

[suningzh]

为什么我把第11行的assert_eq语句注释掉了，最后strong_five还是Some(5)

use std::rc::Rc;
fn main() {
// 创建Rc，持有一个值5
let five = Rc::new(5);

// 通过Rc，创建一个Weak指针
let weak_five = Rc::downgrade(&five);

// Weak引用的资源依然存在，取到值5
let strong_five: Option<Rc<_>> = weak_five.upgrade();
//assert_eq!(*strong_five.unwrap(), 5);

// 手动释放资源`five`
drop(five);

// Weak引用的资源已不存在，因此返回None
let strong_five: Option<Rc<_>> = weak_five.upgrade();
assert_eq!(strong_five, None);

}

[peterhuang621]

'''
impl List {
fn tail(&self) -> Option<&RefCell<Rc>> {
match self {
Cons(_, item) => Some(item),
Nil => None,
}
}
}
'''
这里我查了好些资料才懂，希望作者大大可以标注一下么。
新手，第一遍硬是没懂为什么item匹配得到&RefCell<...>而不是RefCell<...>，后来终于查到match ergonomics:
https://rust-lang.github.io/rfcs/2005-match-ergonomics.html#examples

let p: (&i32, i32) = (&5, 0);
let (x1, y1) = p;
let (x2, y2) = &p;
let (x3, y3) = &&p;
let (&x4, &y4) = p;
let (&x5, &y5) = &p;
let &(x6, y6) = &p;
//let &&(x7, y7) = &p; error

虽然在IDE中会告诉我答案，但是具体怎么发生的希望有大佬总结一下

[blablaboo]

还是objc

[FKHY]

rc<refcell<>>可以实现赋值改变，refcell<rc<>>可以实现指向对象的改变。但是rust提供的指针功能没有可以同时改变这两者的，我只能说是坑不比cpp少到哪里去

[FKHY]

你好，您的邮件已收到，谢谢。

[FKHY]

你好，您的邮件已收到，谢谢。

[liuhhaiffeng]

感觉C++工程化发展过程中踩过的坑, 各个标准的解决方案, Rust也避免不了. 这也说明理论,科学和工程的巨大鸿沟. 约学习Rust, 越觉得其像是C++ 23的一个"安全版子集". 学好Rust后, 不管使用Rust, C语言还是C++, 相信技能会大大增强, 心智负担会大大减小. Rust开发学习, 可以从娃娃抓起, 建议大学课程中可以引入Rust作为计算机学习语言,这样Rust开发人才问题会缓解一大部分.希望Rust能够为我们基础软件自主化创新贡献宝贵力量.

[FKHY]

你好，您的邮件已收到，谢谢。

[FKHY]

你好，您的邮件已收到，谢谢。

[FlandreLiao]

一层套一层，太恐怖了，完全感受不到Rust基础部分的优美...... 难道Rust写稍微复杂些的工程就注定这样吗？

[FKHY]

你好，您的邮件已收到，谢谢。

[inblossoms]

use std::rc::{Rc, Weak};
use std::cell::RefCell;

struct Node {
    value: i32,
    // Node 的父节点：弱引用，用 RefCell 包裹实现内部可变性
    parent: RefCell<Weak<Node>>,
    // Node 的子节点：强引用，用 RefCell 包裹实现内部可变性
    children: RefCell<Vec<Rc<Node>>>,
}

impl Node {
    // 关联函数：创建一个新的 Node 实例，并用 Rc 包裹
    fn new(value: i32) -> Rc<Node> {
        Rc::new(Node {
            value,
            parent: RefCell::new(Weak::new()), // 初始时没有父节点
            children: RefCell::new(vec![]),    // 初始时没有子节点
        })
    }
}

fn main() {
    // 1. 创建根节点和子节点
    let root_node = Node::new(1);  // root_node (Rc<Node>) 强引用 Node { value: 1, ... }
    let child_node = Node::new(2); // child_node (Rc<Node>) 强引用 Node { value: 2, ... }

    // 2. 建立父子关系 (核心步骤)

    // a. 父节点强引用子节点
    // root_node.children 是 RefCell<Vec<Rc<Node>>>
    // 调用 .borrow_mut() 获取 RefCell 内部的可变借用，才能修改 Vec
    root_node.children.borrow_mut().push(Rc::clone(&child_node));
    // 此时，Node { value: 2, ... } 的强引用计数为 2 (由 child_node 和 root_node.children 内部的 Rc 共同拥有)

    // b. 子节点弱引用父节点
    // child_node.parent 是 RefCell<Weak<Node>>
    // 调用 .borrow_mut() 获取 RefCell 内部的可变借用，才能修改 Weak
    // 然后用 Rc::downgrade() 将 root_node 的强引用降级为弱引用，赋值给 child_node 的 parent 字段
    *child_node.parent.borrow_mut() = Rc::downgrade(&root_node);
    // 此时，Node { value: 1, ... } 的强引用计数为 1 (只由 root_node 拥有)
    //                                  弱引用计数为 1 (由 child_node.parent 内部的 Weak 拥有)

    println!("Root node strong count: {}", Rc::strong_count(&root_node)); // 1
    println!("Child node strong count: {}", Rc::strong_count(&child_node)); // 2

    // 3. 验证弱引用是否有效 (在父节点还在时)
    if let Some(parent) = child_node.parent.borrow().upgrade() {
        println!("Child's parent exists: {}", parent.value); // 输出: Child's parent exists: 1
    } else {
        println!("Child's parent does not exist.");
    }

    // 4. 观察生命周期和清理 (核心)
    println!("--- root_node 离开作用域之前 ---");
    drop(child_node); // 手动 drop child_node。Node { value: 2, ... } 的强引用计数从 2 变为 1 (只剩 root_node.children 内部的 Rc)
    println!("Strong count of root_node (after child_node is dropped): {}", Rc::strong_count(&root_node)); // 1
    // 此时，Node { value: 2, ... } 仍然存活，因为它被 root_node.children 强引用着。

} // `root_node` 在这里离开作用域。
  // `root_node` 被 drop，它的 strong_count 变为 0。
  // 它会释放其拥有的 `Node { value: 1, ... }` 实例。
  // 在释放 Node { value: 1, ... } 的过程中，会 drop 其 `children` 字段。
  // `children` 字段的 `Vec<Rc<Node>>` 会被 drop，其中 `Rc<Node { value: 2, ... }>` 被 drop。
  // Node { value: 2, ... } 的 strong_count 变为 0 (因为它之前是 2，现在 1个 Rc 被 drop 掉了)。
  // 最终，Node { value: 2, ... } 也被释放。
  // 内存被完全清理，没有循环引用导致的泄漏。

[FKHY]

你好，您的邮件已收到，谢谢。