迭代器

迭代器是惰性的，调用方法使用迭代器之前，不会有任何的效果。

每个迭代器都实现了iterator trait，这个 trait 定义在标准库里。

trait Iterator {
    type Item;
    // type Item和Self::Item这种用法叫做定义trait的关联类型。这里只定义了这个函数，并没有实现，如果使用自定义迭代器的话，就要在这里的重写next方法。
    fn next(&mut self) -> Option<Self::Item>;
}

fn iter_check() {
    let v1 = vec![1, 2, 3];
    let mut v1_iter = v1.iter();

    if let Some(v) = v1_iter.next() {
        println!("{}", v);
    } else {
        println!("end")
    }
}

next 方法是被要求实现的唯一的一个方法，next一次返回一个元素，当迭代器结束的时候返回None。

迭代可变引用

fn iter_check_mut() {
    // 通过迭代的方法修改列表
    let mut v2 = vec![1, 2, 3];
    let mut v2_iter = v2.iter_mut();
    if let Some(v) = v2_iter.next() {
        *v = 3
    }
    println!("{:?}", v2_iter)
}

自定义迭代器

struct Counter {
    count: u32,
}

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

impl Iterator for Counter {

    type Item = u32;
    fn next(&mut self) -> Option<Self::Item> {
        self.count += 1;
        if self.count < 6 {
            Some(self.count)
        } else {
            None
        }
    }
    
}

fn main() {
    let mut counter = Counter::new();
    for i in (0..6) {
        if let Some(v) = counter.next() {
            println!("{} {}", i, v);
        } else {
            println!("{}", i);
            break;
        }
    }
    println!("Hello, world!");
}