Rust如何为自定义结构体实现Iterator以封装容器

你不需要自行实现所有容器功能，Rust提供了合规的方式复用内置迭代器，核心思路是避开“同时持有容器和其迭代器”的生命周期冲突，以下是两种可行方案：

方案1：提供迭代器生成方法（推荐，符合Rust惯用写法） #

不让UserStore直接实现Iterator，而是给它添加和标准容器一致的迭代器生成方法，直接返回内部容器的内置迭代器。

Vec版本示例 #

struct UserStore<T> {
    inner: Vec<T>,
}

impl<T> UserStore<T> {
    // 返回不可变引用迭代器
    pub fn iter(&self) -> impl Iterator<Item = &T> {
        self.inner.iter()
    }

    // 返回可变引用迭代器
    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
        self.inner.iter_mut()
    }

    // 返回获取所有权的迭代器
    pub fn into_iter(self) -> impl Iterator<Item = T> {
        self.inner.into_iter()
    }
}

HashMap版本示例 #

use std::collections::HashMap;

struct UserStore<K, V> {
    inner: HashMap<K, V>,
}

impl<K, V> UserStore<K, V> {
    pub fn iter(&self) -> impl Iterator<Item = (&K, &V)> {
        self.inner.iter()
    }

    pub fn iter_mut(&mut self) -> impl Iterator<Item = (&K, &mut V)> {
        self.inner.iter_mut()
    }

    pub fn into_iter(self) -> impl Iterator<Item = (K, V)> {
        self.inner.into_iter()
    }
}

使用方式 #

和标准容器的遍历逻辑完全一致：

let mut store = UserStore { inner: vec![1, 2, 3] };

// 不可变遍历
for num in store.iter() {
    println!("{}", num);
}

// 可变遍历
for num in store.iter_mut() {
    *num += 1;
}

// 所有权转移遍历
for num in store.into_iter() {
    println!("{}", num);
}

方案2：让UserStore直接实现Iterator（状态切换方式） #

如果必须让UserStore本身实现Iterator，可以用枚举管理“未迭代”和“正在迭代”的状态，避免同时持有容器和迭代器的冲突。

示例（Vec为例） #

use std::iter::IntoIterator;

enum UserStoreState<T> {
    Uninitialized(Vec<T>),
    Iterating(<Vec<T> as IntoIterator>::IntoIter),
}

struct UserStore<T> {
    state: UserStoreState<T>,
}

impl<T> UserStore<T> {
    pub fn new(inner: Vec<T>) -> Self {
        Self {
            state: UserStoreState::Uninitialized(inner),
        }
    }
}

impl<T> Iterator for UserStore<T> {
    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {
        match &mut self.state {
            UserStoreState::Uninitialized(vec) => {
                // 将容器转换为迭代器，切换状态
                let iter = vec.into_iter();
                self.state = UserStoreState::Iterating(iter);
                self.next()
            }
            UserStoreState::Iterating(iter) => iter.next(),
        }
    }
}

使用方式 #

let store = UserStore::new(vec![1, 2, 3]);
for num in store {
    println!("{}", num);
}

注意：这种方式下，一旦开始迭代，UserStore就无法再访问原容器（所有权已转移给迭代器），符合Rust的安全规则，避免迭代过程中容器被修改导致迭代器失效。

核心原因：为什么不能同时持有容器和迭代器？ #

Rust的借用检查器禁止这种场景：迭代器依赖容器的生命周期，如果结构体同时拥有容器和迭代器，意味着迭代器的生命周期和结构体绑定，但迭代过程中容器可能被修改，导致迭代器失效触发未定义行为，因此Rust从设计上阻止这种风险。

内容的提问来源于stack exchange，提问作者E-rich