如何按指定顺序遍历并消费Rust中的Vec容器？

给定一个Vec<String>和一个包含全排列索引的数组，我们需要按索引指定的顺序移动原Vec中的元素到目标容器，同时要求零额外内存开销，且不能修改原Vec的类型（比如改成Vec<Option<String>>）。

核心思路 #

因为索引是0..src.len()的无重复无遗漏全排列，我们可以直接通过原始指针访问原Vec的元素，逐个移动到目标位置，最后手动释放原Vec的内存空间。这种方式不需要额外分配内存，时间复杂度为O(n)，是零成本的最优方案。

实现1：返回自定义迭代器 #

这个实现返回一个迭代器，允许你按索引顺序遍历并消费原Vec的元素：

use std::ptr;
use std::iter::Iterator;

struct OrderedIntoIter<'a, T> {
    data: *mut T,
    indices: &'a [usize],
    pos: usize,
    cap: usize,
}

impl<'a, T> Iterator for OrderedIntoIter<'a, T> {
    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {
        if self.pos >= self.indices.len() {
            return None;
        }
        let idx = self.indices[self.pos];
        self.pos += 1;
        // 安全前提：索引是合法的全排列，每个位置仅被访问一次
        unsafe { Some(ptr::read(self.data.add(idx))) }
    }
}

impl<'a, T> Drop for OrderedIntoIter<'a, T> {
    fn drop(&mut self) {
        // 所有元素已被取出，仅需释放原Vec的内存空间
        unsafe {
            Vec::from_raw_parts(self.data, 0, self.cap);
        }
    }
}

fn into_iter_in_order<T>(mut src: Vec<T>, indices: &[usize]) -> OrderedIntoIter<'_, T> {
    assert_eq!(src.len(), indices.len(), "索引长度必须和原向量一致");
    
    // 可选：验证索引是合法的全排列，避免非法访问
    let mut seen = vec![false; src.len()];
    for &idx in indices {
        assert!(idx < src.len(), "索引超出范围");
        assert!(!seen[idx], "存在重复索引");
        seen[idx] = true;
    }

    let data = src.as_mut_ptr();
    let cap = src.capacity();
    // 阻止原Vec自动销毁元素，我们将手动处理所有元素
    std::mem::forget(src);

    OrderedIntoIter {
        data,
        indices,
        pos: 0,
        cap,
    }
}

使用示例

fn main() {
    let src = vec!["a".to_string(), "b".to_string(), "c".to_string()];
    let idx_arr = [2_usize, 0, 1];

    let iter = into_iter_in_order(src, &idx_arr);
    for s in iter {
        println!("{}", s); // 输出顺序：c, a, b
    }
}

实现2：直接传入处理闭包 #

如果你不需要迭代器，而是想直接对每个元素执行操作，可以用这个版本：

use std::ptr;

fn consume_vec_in_order<T>(mut src: Vec<T>, indices: &[usize], mut f: impl FnMut(T)) {
    assert_eq!(src.len(), indices.len(), "索引长度必须和原向量一致");
    
    // 可选的索引合法性验证
    let mut seen = vec![false; src.len()];
    for &idx in indices {
        assert!(idx < src.len(), "索引超出范围");
        assert!(!seen[idx], "存在重复索引");
        seen[idx] = true;
    }

    let data = src.as_mut_ptr();
    let cap = src.capacity();
    std::mem::forget(src);

    // 按索引顺序取出元素并传递给闭包
    for &idx in indices {
        let item = unsafe { ptr::read(data.add(idx)) };
        f(item);
    }

    // 释放原Vec的内存空间
    unsafe {
        Vec::from_raw_parts(data, 0, cap);
    }
}

使用示例

fn main() {
    let src = vec!["a".to_string(), "b".to_string(), "c".to_string()];
    let idx_arr = [2_usize, 0, 1];

    consume_vec_in_order(src, &idx_arr, |s| {
        println!("{}", s); // 输出顺序：c, a, b
    });
}

安全性说明 #

这里使用unsafe是安全的，因为满足以下前提：

1. 索引数组是0..src.len()的无重复无遗漏全排列，每个索引仅被访问一次；
2. 所有元素被取出后，原Vec的内存被正确释放，不会造成内存泄漏；
3. 不会访问越界内存或已被移动的元素。

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