Rust 如何在包含可iterable项的结构上定义一个迭代器？

如何在包含已可iterable项的结构上定义一个迭代器？这里是对迭代器的一次尝试

使用rand；
//项目结构
结构Foo{
foo:Vec，
酒吧：Vec，
}
//结构的迭代器
结构FooIter{
foo：迭代器，
条：迭代器，
}
//方法，该方法提供要使用的迭代器
impl-Foo{
fn iter（自我）->FooIter{
食客{
foo:self.foo.iter（）.peek（），
bar:self.bar.iter（）.peek（），
}
}
}
//迭代器中需要的项
枚举条{
MyFloat（f64），
MyInt（i64），
}
//迭代器的实现
FooIter的impl迭代器{
类型项=条；
fn下一步（&mut self）->选项{
匹配（self.foo.peek（），self.far.peek（））{
（有些（)），有些（)）=>{
if rand:：random（）{
self.foo.next（）
}否则{
self.bar.next（）
}
}
（Some（_），None）=>self.foo.next（），
（无，部分（））=>self.bar.next（），
（无，无）=>无，
}
}
}
//在结构上迭代
fn main（）{
让fuz=Foo{
foo:vec！[1.2,2.3,3.4]，
酒吧：vec！[5,6]，
};
对于fuz.iter（）中的项目{
比赛项目{
Bar:：MyFloat（f）=>println！（“float:{}”，f），
Bar:：MyInt（i）=>println！（“int:{}”，i），
}
}
}

---

简而言之，struct

Foo

包含两个向量，我想要一个迭代器在这两个元素之间随机来回跳跃。当然，这里有很多错误，但在核心部分，我不明白如何创建一个结构来为

foo

和

far

项携带迭代器，因为Rust将迭代器定义为一种特性而不是一种类型。

您必须在某个时候定义

迭代器将产生什么，例如，
Iterator src/main.rs:11:5
|
11 | foo:std:：iter:：迭代器，
|^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^在编译时没有已知的大小
|
=帮助：`（dyn std:：iter:：Iterator+'静态）未实现特性`std:：marker:：Sized``
=注意：要了解更多信息，请访问
=注意：只有结构的最后一个字段可以具有动态大小的类型

为了避免动态类型并同时修复错误，让我们定义一些泛型类型：

//结构的迭代器
结构FooIter{
傅:F,，
酒吧：我，
}

我们在
迭代器的实现中添加了必要的

FooIter的impl迭代器
哪里
F：迭代器，
I：迭代器，

我们必须改变生成
FooIter
的方式，这次我们将使用一个神奇的关键字
impl
，这避免了编写可能非常长且不清楚的
迭代器的实际类型，编译器将为我们推断类型。此外，我们必须将该类型绑定到
&self
的生存期，因为只要迭代器存在，它就必须被借用，只需声明
'a
生存期并添加
+'a
即可：

fn iter FooIter{
食客{
foo:self.foo.iter（）.copied（），
bar:self.bar.iter（）.copied（），
}
}

在这里，我们完成了基本操作，下一个问题是您的代码不会生成
Bar
键入
next（）
，因此我们必须更正您的代码，并且最好创建一个适当的随机生成器。最后一段：

使用rand:{rngs:：ThreadRng，thread\rng，rng}；
//项目结构
结构Foo{
foo:Vec，
酒吧：Vec，
}
//结构的迭代器
用于FooIter的结构FooIter迭代器
哪里
F：迭代器，
I：迭代器，
{
傅：可以偷看，
酒吧：可以看，
rng:&r多线程rng，
}
//方法，该方法提供要使用的迭代器
impl-Foo{
fn iter@Stargateur主要对我进行了分类，但我想包含两个独立的代码来完成这项工作。以下是与我最初尝试的代码稍微接近的固定代码，它适用于Rust 1.34.1：

//项目的结构
结构Foo{
foo:Vec，
far:Vec，
}
//结构的迭代器
结构FooIter
哪里
FloatIter：迭代器，
IntIter：迭代器，
{
foo:std:：iter:：Peekable，
far:std:：iter:：可窥视，
}
//方法，该方法提供要使用的迭代器
impl-Foo{
fn国际热核聚变炉{
食客{
foo:self.foo.iter（），
far:self.far.iter（）.cloned（）.peekable（），
}
}
}
//迭代器中需要的项
枚举条{
MyFloat（f64），
MyInt（i64），
}
//迭代器的实现
FooIter的impl迭代器
哪里
FloatIter：迭代器，
IntIter：迭代器，
{
类型项=条；
fn下一步（&mut self）->选项{
匹配（self.foo.peek（），self.far.peek（））{
（有些（)），有些（)）=>{
if rand:：random（）{
self.foo.next（）.map（|x | Bar:：MyFloat（x））
}否则{
self.far.next（）.map（|x | Bar:：MyInt（x））
}
}
（Some（|），None）=>self.foo.next（）.map（|x | Bar:：MyFloat（x）），
（None，Some（））=>self.far.next（）.map（|x | Bar:：MyInt（x）），
（无，无）=>无，
}
}
}
//在结构上迭代
fn main（）{
让fuz=Foo{
foo:vec！[1.2,2.3,3.4]，
far:vec！[5,6]，
};
对于fuz.iter（）中的项目{
比赛项目{
Bar:：MyFloat（f）=>println！（“float:{}”，f），
Bar:：MyInt（i）=>println！（“int:{}”，i），
}
}
}

帮助我理解发生了什么是
FooIter
参数化了泛型类型上的参数。这些类型是通过在
iter
方法的
Foo
的返回位置使用
impl Trait
推断出来的。也就是说，我能够编写类似的代码而不使用这个推断