C++可重复获取迭代器当前值，Rust能否不移动迭代器位置取值？

C里的迭代器可以像指针一样，多次解引用获取当前位置的元素而不移动迭代器，但Rust的标准迭代器是消费型的——调用next()就会让迭代器前进到下一个位置，并且交出当前元素的所有权或引用。不过我们可以通过几种方式实现类似C的效果：

方法1：使用Peekable适配器查看下一个元素 #

Peekable是标准库提供的迭代器适配器，它允许你调用peek()方法查看下一个即将被next()返回的元素，而不会移动迭代器本身。适合还没调用next()时提前查看，或者在调用next()后查看后续元素：

fn main() {
    let s = String::from("abcd");
    let mut iter = s.chars().peekable();
    
    // 多次查看第一个元素，迭代器不会移动
    println!("{:?}", iter.peek()); // 输出 Some('a')
    println!("{:?}", iter.peek()); // 还是输出 Some('a')
    
    // 调用next()后，迭代器前进到下一个位置
    let first_char = iter.next();
    println!("{:?}", first_char); // 输出 Some('a')
    
    // 现在peek()查看的是下一个元素
    println!("{:?}", iter.peek()); // 输出 Some('b')
}

方法2：手动保存当前元素 #

这是最直接的方式：每次调用next()后，把返回的元素保存到一个变量里，之后就可以多次访问这个变量的值，完全模拟C++中多次解引用迭代器的行为：

fn main() {
    let s = String::from("abcd");
    let mut iter = s.chars();
    // 先获取第一个元素并保存
    let mut current = iter.next();
    
    // 多次访问当前保存的元素
    println!("{:?}", current); // 输出 Some('a')
    println!("{:?}", current); // 还是输出 Some('a')
    
    // 前进到下一个元素，更新current变量
    current = iter.next();
    println!("{:?}", current); // 输出 Some('b')
}

方法3：自定义迭代器实现类似C++的行为 #

如果需要一个更贴近C++迭代器的类型（可以随时获取当前位置元素，同时控制前进），可以自己实现一个迭代器，内部维护当前位置的索引或状态：

// 自定义字符迭代器，持有字符串引用和当前索引
struct CharIterator<'a> {
    s: &'a str,
    index: usize,
}

impl<'a> CharIterator<'a> {
    // 创建新的迭代器实例
    fn new(s: &'a str) -> Self {
        CharIterator { s, index: 0 }
    }
    
    // 获取当前位置的元素，不移动迭代器
    fn current(&self) -> Option<char> {
        self.s.chars().nth(self.index)
    }
}

// 实现Rust的Iterator trait，让自定义类型成为迭代器
impl<'a> Iterator for CharIterator<'a> {
    type Item = char;
    
    // 前进到下一个元素并返回当前元素
    fn next(&mut self) -> Option<Self::Item> {
        let current_char = self.current();
        // 如果还有元素，索引+1
        if current_char.is_some() {
            self.index += 1;
        }
        current_char
    }
}

fn main() {
    let s = String::from("abcd");
    let mut iter = CharIterator::new(&s);
    
    // 多次获取当前元素，迭代器不移动
    println!("{:?}", iter.current()); // 输出 Some('a')
    println!("{:?}", iter.current()); // 输出 Some('a')
    
    // 前进到下一个元素
    iter.next();
    println!("{:?}", iter.current()); // 输出 Some('b')
}

补充说明 #

Rust标准迭代器设计成消费型，是为了适配更广泛的场景——比如处理一次性的数据流（如网络请求输出、文件读取），这类数据源无法回头查看之前的元素。同时消费型迭代器也能避免很多悬空引用的安全问题，符合Rust的内存安全设计原则。

内容的提问来源于stack exchange，提问作者mascai