too-many-lists/ok-stack/iter

[giscus[bot]]

too-many-lists/ok-stack/iter

https://course.rs/too-many-lists/ok-stack/iter.html

[yangs1]

            self.next = node.next.as_ref().take().map(| rde| &**rde);

[yangs1]

请教下，为什么这里不会自动解引用？

[sunface]

编译器不够聪明 = , =

[GeniusPenguin9]

1, 首先我尝试理解你的问题是这段代码为何不能写成Iter { next: self.head }让其自动解引用

    pub fn iter<'a>(&'a self) -> Iter<'a, T> {
        Iter { next: self.head.as_deref() } 
    }

2, 检查参数匹配：
传入self.head的类型是Option<Box<Node>>
期望next类型是Option<&'a Node>

3, 根据deref引用归一化总结，可以看出rust编译器是从外层开始解引用的，内部调用deref()。在这个问题中，类型最外层是Option<>

let mut _2: &i32;
let _3: &&&&i32;

bb0: {
    _2 = (*(*(*_3)))
}

4, 查看option.rs源码会发现，option本身并没有实现一个fn deref(&self) -> &Self::Target，但其提供了as_deref方法，对Some场景下的内部成员提供解引用。

    pub const fn as_deref(&self) -> Option<&T::Target>
    where
        T: ~const Deref,
    {
        match self.as_ref() {
            Some(t) => Some(t.deref()),
            None => None,
        }
    }

5, 总结
self.head // Option<Box<Node>>
.as_deref()
|---Option<Box<Node>.deref()>
|--- After auto deref, Box<Node> => &Node
|---Option<&'a Node>

[luqihang]

Rust从入门到放弃，看了这一章，感觉像前面没学一样😢😢😢

[weq95]

我也是,哈哈哈,多学几遍,让后做项目应该会好很多把

[NicholasFirst]

这一章难度陡增, 有的地方要反应好久才能理解.....

[gnauhtt]

哈哈哈，代码拷贝到ide去，有变量类型显示，会容易理解一些

[478619644h]

今天的开心到此为止吧 :(

[zwl773993221]

前面看的还算是开心，看到这里完全懵逼了

[changjiashuai]

前面都学废了😮‍💨

[GeniusPenguin9]

impl<T> List<T> {
    // 此处iter的构造函数满足编译器消除规则2："若存在多个输入生命周期，且其中一个是 &self 或 &mut self，则 &self 的生命周期被赋给所有的输出生命周期"
    // 这个签名可以不写显示生命周期，优化成 `pub fn iter(&self) -> Iter<T>`
    pub fn iter<'a>(&'a self) -> Iter<'a, T> { 
        Iter { next: self.head.as_deref() }
    }
}

[GeniusPenguin9]

抱歉……我在看到该章节中间就留言了，重复comment...请忽略

[jiangshengdev]

impl<'a, T> Iterator for Iter<'a, T> {
    type Item = &'a T;

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        let old_next = self.next;

        match old_next {
            None => None,
            Some(old_node) => {
                let next_next: &Link<T> = &old_node.next;

                let new_next = match next_next {
                    None => None,
                    Some(boxed_node) => {
                        let new_node = &**boxed_node;
                        Some(new_node)
                    }
                };

                self.next = new_next;
                let elem = &old_node.elem;
                Some(elem)
            }
        }
    }
}

把上述代码使用match实现，可以发现代码量变得很多，个人感觉match这样或许可以方便理解。
配合IDE查看各个中间变量的类型。
完整的代码可见：
https://github.com/jiangshengdev/rust-dsa/blob/5b25b1c382d6fb47ab720a7489612602015f2866/src/stack/mod.rs

[0xDamn]

如果Iter的定义改一下的话实现起来会简化很多：

pub struct Iter<T> {
    next: &'a Link<T>, // same as &'a Option<Box<Node<T>>>
}

这里是完整版：

pub struct Iter<'a, T> {
    next: &'a Link<T>,
}

impl<'a, T> Iterator for Iter<'a, T> {
    type Item = &'a T;
    fn next(&mut self) -> Option<Self::Item> {
        match self.next {
            None => None,
            Some(node) => {
                self.next = &node.next;
                Some(&node.elem)
            }
        }
    }
}

impl<'a, T> IntoIterator for &'a LinkList<T> {
    type Item = &'a T;
    type IntoIter = Iter<'a, T>;

    fn into_iter(self) -> Self::IntoIter {
        Iter { next: &self.head }
    }
}

impl<T> LinkList<T> {
    //snap
    pub fn iter<'a>(&'a self) -> Iter<'a, T> {
        self.into_iter()
    }
}

[XieyangLy]

刚开始学rust，对你这个方法有个疑问：
原文是
pub struct Iter<'a, T> {
next: Option<&'a Node>,
}
按照您的方法，是 next::Option<Box<Node>>
会多一个智能指针。

[chaoliu719]

对实现了 Iterator trait 的类型，rust 会自动实现 IntoIterator trait。不用再套一层元组结构体吧。

impl<T> Iterator for List<T> {
    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {
        self.pop()
    }
}

[guopenghui]

一般没这么用的吧，容器是容器，迭代器是迭代器。其他容器也都是先生成迭代器然后再用。

像是标准库里面的vec_deque，也是用IntoIter封装一层

// https://doc.rust-lang.org/src/alloc/collections/vec_deque/into_iter.rs.html#17-20
pub struct IntoIter<
    T,
    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
> {
    inner: VecDeque<T, A>,
}

impl<T, A: Allocator> IntoIter<T, A> {
    pub(super) fn new(inner: VecDeque<T, A>) -> Self {
        IntoIter { inner }
    }

    pub(super) fn into_vecdeque(self) -> VecDeque<T, A> {
        self.inner
    }
}

[chaoliu719]

确实，先生成 IntoIter 迭代器，再 next()。我想简单了，以为只要把 List 消耗掉就可以，但其实很多 IntoIter 结构会存储一些别的东西。感谢指出。

[jeferwang]

头都大了😅

[sswybd]

"事实上，还可以使用另一种方式来实现："
里作者写的是 self.next = node.next.as_ref().map::<&Node<T>, _>(|node| &node);
但其实也可以 self.next = node.next.as_ref().map::<&Node<T>, _>(|node| node); 或加任意多的&。
（一个小补充）