Rust for cpp devs - 迭代器

迭代器（Iterator）可以允许对序列中的每一个元素执行某个操作。

Rust 的迭代器分为三种：

• iter() 返回一个常量引用，不可改变元素的值
• iter_mut() 返回一个可变引用，能够修改元素的值
• into_iter() 会拿走容器的 ownership

Iterator Trait

迭代器实现了 Iterator trait，定义如下（type Item 的用法在后面例子中会讲）：

pub trait Iterator {
    type Item;

    fn next(&mut self) -> Option<Self::Item>;

    // methods with default implementations elided
}

Iterator trait 要求必须实现 next 方法，它返回一个封装在 Some 中的元素，如果没有下一个元素，则返回 None。之所以要求必须实现 next，是因为 Iterator 默认实现的某些其他方法会调用。

例如：

#[cfg(test)]
mod tests {
    #[test]
    fn iterator_demonstration() {
        let v1 = vec![1, 2, 3];

        let mut v1_iter = v1.iter();

        assert_eq!(v1_iter.next(), Some(&1));
        assert_eq!(v1_iter.next(), Some(&2));
        assert_eq!(v1_iter.next(), Some(&3));
        assert_eq!(v1_iter.next(), None);
    }
}

值得注意的是迭代器变量定义为 mut，因为每次调用 next 都会修改迭代器指向下一个元素。

消耗 Iterator

Iterator trait 中调用 next 的方法称为 consuming adaptors。因为使用这些方法会“耗尽”这个迭代器，例如 sum。由于迭代器都是惰性的，必须使用 consuming adaptors 才能得到运行结果。

    #[test]
    fn iterator_sum() {
        let v1 = vec![1, 2, 3];
        let v1_iter = v1.iter();
        let total: u32 = v1_iter.sum();
        assert_eq!(total, 6);
    }

此后无法再使用 v1_iter，因为sum 已经拿走了它的 ownership。

生成 Iterator

除了消耗 Iterator 的， 也有生成 Iterator 的方法，称为 iterator adaptors。但是生成后的 Iterator 上必须使用 consuming adaptors 来得到结果。

例如，map 方法可以将旧的 iterator 映射到一个新的 iterator。下面的代码将 v1 中的每个元素加 1 并生成一个 v2。注意，map 只是做了 iterator 的映射，并不是直接把 v1 变成 v2。

    #[test]
    fn iterator_map() {
        let v1 = vec![1, 2, 3];
        let v1_iter = v1.iter();
        let v2_iter = v1_iter.map(|x| {x + 1});
        let v2: Vec<_> = v2_iter.collect();

        assert_eq!(v2, vec![2, 3, 4]);
    }

还有一个常用的 iterator adapter 是 filter 方法：

#[derive(PartialEq, Debug)]
struct Shoe {
    size: u32,
    style: String,
}

fn shoes_in_my_size(shoes: Vec<Shoe>, shoe_size: u32) -> Vec<Shoe> {
    shoes.into_iter().filter(|s| s.size == shoe_size).collect()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn filters_by_size() {
        let shoes = vec![
            Shoe {
                size: 10,
                style: String::from("sneaker"),
            },
            Shoe {
                size: 13,
                style: String::from("sandal"),
            },
            Shoe {
                size: 10,
                style: String::from("boot"),
            },
        ];

        let in_my_size = shoes_in_my_size(shoes, 10);

        assert_eq!(
            in_my_size,
            vec![
                Shoe {
                    size: 10,
                    style: String::from("sneaker")
                },
                Shoe {
                    size: 10,
                    style: String::from("boot")
                },
            ]
        );
    }
}

shoes_in_my_size 函数筛选出所有大小为 10 的鞋。filter 也是一个从 iterator 到 iterator 的映射。在这里，我们使用 into_iter 拿走了原来的容器的 ownership。

自定义 Iterator

我们定义了一个计数器类：

struct Counter {
    count: u32,
}

impl Counter {
    fn new() -> Counter {
        return Counter{count: 0};
    }
}

然后让它实现 Iterator trait，计数到 5 终止：

impl Iterator for Counter {
    type Item = u32;  // call to next() will return Option<u32>

    fn next(&mut self) -> Option<Self::Item> {
        if self.count < 5 {
            self.count += 1;
            return Some(self.count);
        }

        return None;  // return None when iteration ends
    }
}

这里值得注意的点已经在注释中标出。测试代码如下：

    #[test]
    fn test_counter() {
        let mut counter = Counter::new();

        assert_eq!(counter.next(), Some(1));
        assert_eq!(counter.next(), Some(2));
        assert_eq!(counter.next(), Some(3));
        assert_eq!(counter.next(), Some(4));
        assert_eq!(counter.next(), Some(5));
        assert_eq!(counter.next(), None);
    }