Rust迭代器持有可变引用后，为何无法再次引用原Vec？

问题描述 #

将Vec的可变引用传递给迭代器，让迭代器在遍历过程中向Vec添加元素，仅记录元素的索引。预期迭代器使用完毕后可以正常引用该Vec，但实际编译报错。

示例代码：

struct MyElement{
    category_index: usize,
    // 其他字段省略
}

impl MyElement{
    fn iter_from_src<'a>(source: &'a str, categories: &'a mut Vec<&'a str>)
      -> impl Iterator< Item = MyElement > {
        std::iter::from_fn(move || -> Option<MyElement> {
            // 模拟从source提取分类的逻辑
            let category = "test"; // 替换为实际的find_category_in_source逻辑
            
            if let Some(index) = categories.iter().position(|c| *c == category) {
                Some( MyElement{ category_index: index } )
            } else {
                let index = categories.len();
                categories.push(category);
                Some( MyElement{ category_index: index } )
            }
        })
    }
}

fn main() {
    let source: String = String::from("sample source");
    let mut categories = Vec::with_capacity(32);
    let mut elements = Vec::with_capacity(1024);
    
    for element in MyElement::iter_from_src(&source, &mut categories) {
        elements.push(element);
    }

    // 此处编译报错
    println!("{categories:#?}");
}

编译器报错：

error[E0502]: cannot borrow `categories` as immutable because it is also borrowed as mutable
  --> src/main.rs:81:16
   |
74 |     for element in MyElement::iter_from_src(&source, &mut categories) {
   |                                                      --------------- mutable borrow occurs here
...
81 |     println!("{categories:#?}");
   |                ^^^^^^^^^^
   |                |
   |                immutable borrow occurs here
   |                mutable borrow later used here

错误原因 #

1. 生命周期绑定过宽：函数iter_from_src仅使用了单个生命周期'a，导致编译器将迭代器的生命周期与source、categories的生命周期强制绑定。由于source是main中String的引用，生命周期覆盖整个main函数，因此categories的可变借用被延长至整个main周期，后续的不可变借用自然触发冲突。
2. 编译器无法感知无引用传递：虽然MyElement仅存储了索引，没有持有categories的任何引用，但编译器无法智能识别这一点——它只会严格遵循借用规则，认为迭代器捕获了categories的可变引用，因此迭代器存在期间categories被独占。

解决方案 #

方案1：分离生命周期（零开销，推荐） #

修改函数签名，将source和categories的生命周期分离，让迭代器的生命周期仅绑定到categories的引用周期，而非source的完整生命周期：

struct MyElement {
    category_index: usize,
    // 其他字段...
}

impl MyElement {
    // 分离'a（source的生命周期）和'b（categories引用的生命周期）
    fn iter_from_src<'a, 'b>(source: &'a str, categories: &'b mut Vec<&'a str>) 
        -> impl Iterator<Item = MyElement> + 'b {
        std::iter::from_fn(move || -> Option<MyElement> {
            let category = "test"; // 替换为实际的分类提取逻辑
            
            if let Some(index) = categories.iter().position(|c| *c == category) {
                Some(MyElement { category_index: index })
            } else {
                let index = categories.len();
                categories.push(category);
                Some(MyElement { category_index: index })
            }
        })
    }
}

fn main() {
    let source = String::from("sample source");
    let mut categories = Vec::with_capacity(32);
    let mut elements = Vec::with_capacity(1024);
    
    for element in MyElement::iter_from_src(&source, &mut categories) {
        elements.push(element);
        // 可根据实际逻辑添加迭代终止条件
        if elements.len() >= 5 {
            break;
        }
    }

    // 现在可以正常使用categories
    println!("{categories:#?}");
}

修改后，迭代器的生命周期'b会在循环结束（迭代器销毁）后立即结束，categories的可变借用随之释放，后续的不可变借用不再冲突。

方案2：使用内部可变性（适合复杂场景） #

如果逻辑复杂无法通过生命周期分离解决，可使用RefCell实现内部可变性，将categories包装为RefCell<Vec<&str>>，外部传递不可变引用，内部通过borrow_mut()修改：

use std::cell::RefCell;

struct MyElement {
    category_index: usize,
    // 其他字段...
}

impl MyElement {
    fn iter_from_src<'a>(source: &'a str, categories: &'a RefCell<Vec<&'a str>>) 
        -> impl Iterator<Item = MyElement> + 'a {
        std::iter::from_fn(move || -> Option<MyElement> {
            let category = "test"; // 替换为实际的分类提取逻辑
            
            let categories_ref = categories.borrow();
            let index = if let Some(idx) = categories_ref.iter().position(|c| *c == category) {
                idx
            } else {
                drop(categories_ref); // 提前释放不可变借用
                let mut categories_mut = categories.borrow_mut();
                let idx = categories_mut.len();
                categories_mut.push(category);
                idx
            };
            
            Some(MyElement { category_index: index })
        })
    }
}

fn main() {
    let source = String::from("sample source");
    let categories = RefCell::new(Vec::with_capacity(32));
    let mut elements = Vec::with_capacity(1024);
    
    for element in MyElement::iter_from_src(&source, &categories) {
        elements.push(element);
        if elements.len() >= 5 {
            break;
        }
    }

    println!("{:#?}", categories.borrow());
}

注意：RefCell的借用检查在运行时进行，若同一时间存在多个可变借用会触发 panic，需确保逻辑安全。

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