为包含可迭代字段的结构实现迭代器特征

Question

我想为包含可迭代字段的结构实现 Iterator 特征。迭代我的结构应该产生与迭代该字段相同的结果。这就是我想要的（显然不起作用）：

struct Foo {
    bar: Vec<char>,
}

impl Iterator for Foo {
    type Item: &char; // Error: expected named lifetime parameter
    
    fn next(&mut self) -> Option<Self::Item> {
        self.bar.iter().next()
    }
}

为避免该错误，我尝试插入生命周期：

use std::marker::PhantomData;

struct Foo<'a> {
    bar: Vec<char>,
    phantom: &'a PhantomData<char> // not sure what to put inside < .. >
}

impl<'a> Iterator for Foo<'a> {
    type Item = &'a char;

    fn next(&mut self) -> Option<Self::Item> {
        self.bar.iter().next() // again, several errors about lifetimes
    }
}

如何为这样的结构实现 Iterator 特性？

Answer 1

迭代器是一个有状态的对象，它会记住它在底层集合中的位置。在您的示例中，每次调用 next() 都会从头开始迭代 return 第一个元素（前提是错误已修复）。

为 Foo 实现 Iterator 意味着实例本身会在每次调用 next() 时发生变化，这就是为什么迭代器通常有自己的结构。

如果你想提供迭代功能，我建议添加一个 iter() 函数，它可以 return 一个 std::slice::Iter （其中 Vec::iter() returns ).

struct Foo {
    bar: Vec<char>,
}

impl Foo { 
    pub fn iter(&self) -> impl Iterator<Item=&char> + '_ {
        self.bar.iter()
    }
}

Answer 2

创建 Iterator 的东西和创建 Iterator 的东西之间有很大的区别。例如，Vec<char> 可以产生迭代器，但它本身不是迭代器。以下是两者的几个简单示例，希望您能找到适合您用例的内容。

生成迭代器

针对您的情况，最简单的方法是只为该字段实施 Deref，然后让 Vec<char> 处理它。或者，您可以为 bar.iter().

编写包装函数

pub struct Foo {
    bar: Vec<char>,
}

impl Deref for Foo {
    type Target = Vec<char>;

    fn deref(&self) -> &Self::Target {
        &self.bar
    }
}

let foo = Foo { bar: vec!['a', 'b', 'c', 'd'] };

// deref is implicitly called so foo.iter() represents foo.bar.iter()
for x in foo.iter() {
    println!("{:?}", x);
}

编写迭代器

下面是如何为 Vec<char> 编写自己的迭代器。请注意 Vec 如何存储为引用而不是拥有的值。这样 Rust 就可以解决生命周期限制。通过在迭代器的生命周期内持有一个不可变的引用，我们保证这个迭代器产生的引用也可以在该生命周期内持续存在。如果我们使用拥有的值，我们只能保证元素引用的生命周期持续到下一次对迭代器进行可变引用。或者换句话说，每个值只能持续到 next 被再次调用。然而，即使这样也需要夜间功能才能正确表达。

pub struct SimpleIter<'a> {
    values: &'a Vec<char>,
    index: usize,
}

impl<'a> Iterator for SimpleIter<'a> {
    type Item = &'a char;
    
    fn next(&mut self) -> Option<Self::Item> {
        if self.index >= self.values.len() {
            return None
        }
        
        self.index += 1;
        Some(&self.values[self.index - 1])
    }
}

这是一个通用迭代器包装另一个迭代器的简单示例。

// Add ?Sized so Foo can hold a dynamically sized type to satisfy IntoFoo
struct Foo<I: ?Sized> {
    bar: I,
}

impl<I: Iterator> Iterator for Foo<I> {
    type Item = <I as Iterator>::Item;
    
    fn next(&mut self) -> Option<Self::Item> {
        println!("Iterating through Foo");
        self.bar.next()
    }
}

您还可以通过创建易于使用 Foo.

的特征来更喜欢它

pub trait IntoFoo {
    fn iter_foo(self) -> Foo<Self>;
}

// Add an iter_foo() method for all existing iterators
impl<T: Iterator> IntoFoo for T {
    fn iter_foo(self) -> Foo<Self> {
        Foo { bar: self }
    }
}


let values = vec!['a', 'b', 'c', 'd'];

// Get default iterator and wrap it with our foo iterator
let foo: Foo<std::slice::Iter<'_, char>> = values.iter().iter_foo();

for x in foo {
    println!("{:?}", x);
}

Answer 3

这是 moi 的一个厚颜无耻的实现。只是因为我刚接触 rust :)

fn main() {
    let stream = ScoreStream::new(vec![32, 21, 37]);

    let i = stream.into_iter();
    for a in i {
        print!("\n {}", a);
    }
}

struct ScoreStream {
    vals: Vec<i32>,
    count: usize,
}

impl ScoreStream {
    fn new(vals: Vec<i32>) -> Self {
        Self { vals, count: 0 }
    }
}

impl Iterator for ScoreStream {
    type Item = i32;
    fn next(&mut self) -> Option<Self::Item> {
        let res = self.vals.get(self.count);
        match res {
            Some(v) => {
                self.count += 1;
                Some(*v)
            },
            None => None,
        }
    }
}

Answer 4

我的结构上有#[readonly::make]。这不会导致只读问题，而且看起来很简单：

use std::slice::Iter;

pub fn iter(&self) -> Iter<Foo> {
    self.bar.iter()
}

它可能违反了一些东西，但我在简单的代码中使用它没有问题。

为包含可迭代字段的结构实现迭代器特征

Implement Iterator trait for a struct containing an iterable field

rust

iterator

traits

生成迭代器

编写迭代器