在 Rust 中, for 语句的执行依赖于类型对于 IntoIterator 的实现, 如果某类型实现了这个 trait, 那么它就可以直接使用 for 进行循环.

直接实现

在 Rust 中, 如果一个类型实现了 Iterator, 那么它会被同时实现 IntoIterator, 具体逻辑是返回自身, 因为自身就是迭代器.

但是如果自身就是迭代器的话, 就意味着自身必须存储迭代状态, 例如当前迭代的位置. 如果是这样的话, 迭代器就只能被使用一次. 况且自身直接被传入 into_iter 方法后, 所有权被转移, 该对象就无法被再次使用了.

定义类型本身:

struct IntRange {current: i32,step: i32,end: i32
}

直接为其实现迭代器:

impl Iterator for IntRange {type Item = i32;fn next(&mut self) -> Option<Self::Item> {if self.current == self.end {return None;} else {let current = self.current;self.current += self.step;return Some(current);}}
}

使用该类型:

let range = IntRange { current: 0, step: 1, end: 10 };
for value in range {println!("v: {}", value);
}

所以结论是, 如果你的类型是一次性用品, 你可以直接对其实现 Iterator

手动实现迭代器

如果你向手动实现类似于容器的东西, 那么它当然不是一次性的. 我们应该仿照 Rust 中对切片的迭代器实现.

1. 同时实现会转移所有权和不会转移所有权的两个迭代器
2. 对 self 和 &self 都实现 IntoIterator, 这样就可以做不转移所有权的迭代了

类型本身:

struct IntRange {step: i32,end: i32
}

两个迭代器:

struct IntRangeIter<'a> {range: &'a IntRange,current: i32,
}struct IntRangeIntoIter {range: IntRange,current: i32,
}

两个迭代器实现:

impl Iterator for IntRangeIter<'_> {type Item = i32;fn next(&mut self) -> Option<Self::Item> {if self.current == self.range.end {return None;} else {let current = self.current;self.current += self.range.step;return Some(current);}}
}impl Iterator for IntRangeIntoIter {type Item = i32;fn next(&mut self) -> Option<Self::Item> {if self.current == self.range.end {return None;} else {let current = self.current;self.current += self.range.step;return Some(current);}}
}

实现返回两种迭代器的 IntoIterator:

impl<'a> IntoIterator for &'a IntRange {type Item = i32;type IntoIter = IntRangeIter<'a>;fn into_iter(self) -> Self::IntoIter {IntRangeIter {range: self,current: 0}}
}impl IntoIterator for IntRange {type Item = i32;type IntoIter = IntRangeIntoIter;fn into_iter(self) -> Self::IntoIter {IntRangeIntoIter {range: self,current: 0}}
}

使用它:

let range = IntRange { step: 1, end: 10 };// 可以使用引用来进行 for 循环
for value in &range {println!("v: {}", value);
}// 也可以直接对其进行 for 循环
for value in range {println!("v: {}", value);
}

切片对迭代的实现

我们知道, Rust 的切片有一个 iter 方法, 其实它就相当于对当前切片的引用调用 into_iter.

其实, 在调用切片引用的 into_iter 方法时, 本质上就是调用的其 iter 方法. 方法的实现是在 iter 内的.

let v = vec![1, 2, 3];// 下面两个调用是等价的
let iter1 = v.iter();
let iter2 = (&v).into_iter();

如果你希望实现迭代变量可变的迭代器, 还可以为 &mut T 实现 into_iter, 当然, Rust 内部对于切片的实现, 也是这样的:

let mut v = vec![1, 2, 3];// 下面两个调用是等价的
let mutIter = v.iter_mut();
let mutIter = (&mut v).into_iter();

总结

两种类型:

1. 对于一次性使用的类型, 可以直接对其实现迭代器 trait.

2. 对于容器, 不应该对容器本身直接实现迭代器, 而是应该单独创建迭代器类型, 然后对其本身实现 IntoIterator

为了方便用户使用, 调用之间的实现应该是这样:

1. 实现 T 的 IntoIterator
2. 实现 &T 的 iter 函数, 返回借用的迭代器.
3. 实训 &mut T 的 iter_mut 函数, 返回可变借用的迭代器.
4. 对 &T 和 &mut T 实现 into_iter 函数, 并在内部调用刚刚实现的 iter 和 iter_mut 函数.

这样, 用户就可以直接调用 iter 方法获得借用的迭代器, 然后使用 map, filter 等方法进行集合的复杂操作了