是否可以为包含向量的元组结构使用 Impl 迭代器？

问题描述

如果我创建一个包含 Vec<i32> 的结构，我可以在其上实现 Iterator 特征：

struct MyVec2 {
    counter: usize,my_vec: Vec<i32>,}

impl MyVec2 {
    fn new(my_vec: Vec<i32>) -> Self {
        Self { counter: 0,my_vec }
    }
}

impl Iterator for MyVec2 {
    type Item = i32;

    fn next(&mut self) -> Option<Self::Item> {
        let i = self.my_vec.get(self.counter)?;
        self.counter += 1;
        Some(*i)
    }
}

fn main() {
    let mv2 = MyVec2::new(vec![1,2,3]);
    for i in mv2 {
        println!("{}",i);
    }
}

有没有办法为这种形式的元组结构实现 Iterator？

struct MyVec(Vec<i32>);

这样我就可以这样称呼它？

pub fn main() {
    let mv = MyVec(vec![1,3]);

    for i in mv {
        println!("{}",i);
    }
}

我尝试过的所有解决方案要么产生了我似乎无法绕过的编译器错误，要么最终陷入了无限循环（例如，在外部 {{1} 内的向量上调用 .next() 时}} 方法）。

这能解决吗？

解决方法

按照上面评论中的建议，我继续实现了一个包装结构，它位于原始元组结构周围，并保持一个计数器。

pub fn main() {
    let mv = MyVec(vec![1,2,3]);

    for i in mv.iter() {
        println!("{}",i);
    }
}

struct MyVec<T>(Vec<T>);

// ---------------- wrapper

struct MyVecIterator<'a,T> {
    counter: usize,my_vec: &'a MyVec<T>,}

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

    fn next(&mut self) -> Option<Self::Item> {
        let i = self.my_vec.0.get(self.counter)?;
        self.counter += 1;
        Some(i)
    }
}

trait Iter<T> {
    fn iter(&self) -> MyVecIterator<T>;
}

impl<T> Iter<T> for MyVec<T> {
    fn iter(&self) -> MyVecIterator<T> {
        MyVecIterator {
            counter: 0,my_vec: self
        }
    }
}

我想我最初的问题的答案是它是可以解决的，但你仍然需要一个计数器。希望可以帮助任何人在未来使用谷歌搜索。感谢大家的帮助！