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!();
        }
    }

[YtxCash]

为什么去掉*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);
}

[YtxCash]

查了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]

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