如何实现持有自有缓冲区的窗口迭代器（不拷贝数据）

你的问题本质是标准Iterator trait无法返回依赖于自身生命周期的引用，同时初始代码中存在引用悬空的问题。以下是几种可行的解决方法：

1. 用索引替代内部引用（无需unsafe/nightly） #

放弃在结构体中存储切片引用，改用索引跟踪窗口位置，自定义迭代器 trait 来返回绑定到当前&mut self生命周期的切片：

// 自定义借出迭代器 trait
trait LendingIterator {
    type Item<'a> where Self: 'a;
    fn next(&mut self) -> Option<Self::Item<'_>>;
}

struct Slicer {
    full: Vec<u32>,
    end_idx: usize,
}

impl Slicer {
    fn new() -> Self {
        let full = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
        Slicer {
            full,
            end_idx: full.len(),
        }
    }
}

impl LendingIterator for Slicer {
    type Item<'a> = &'a [u32] where Self: 'a;

    fn next(&mut self) -> Option<Self::Item<'_>> {
        if self.end_idx == 0 {
            return None;
        }
        self.end_idx -= 1;
        // 根据索引生成切片，引用绑定到当前&mut self的生命周期
        Some(&self.full[0..self.end_idx])
    }
}

fn main() {
    let mut slicer = Slicer::new();
    while let Some(slice) = slicer.next() {
        println!("{slice:?}");
    }
}

这种方法完全安全，无需unsafe或nightly特性，但无法使用标准库的迭代器适配器（如map、filter），只能使用自定义逻辑。

2. 使用Unsafe代码（稳定版可用） #

通过原始指针存储当前切片，规避编译器的生命周期检查（需确保指针始终有效）：

struct Slicer {
    full: Vec<u32>,
    cur_slice: *mut [u32],
}

impl Slicer {
    fn new() -> Self {
        let mut full = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
        let cur_slice = full.as_mut_slice() as *mut _;
        Slicer { full, cur_slice }
    }
}

impl Iterator for Slicer {
    type Item = &'_[u32];

    fn next(&mut self) -> Option<Self::Item> {
        unsafe {
            let slice = &mut *self.cur_slice;
            if slice.is_empty() {
                return None;
            }
            // 更新切片指针
            let new_len = slice.len() - 1;
            let new_slice = &mut slice[..new_len];
            self.cur_slice = new_slice as *mut _;
            // 返回不可变切片
            Some(new_slice as &[u32])
        }
    }
}

fn main() {
    let mut slicer = Slicer::new();
    while let Some(slice) = slicer.next() {
        println!("{slice:?}");
    }
}

安全性说明 #

这里的unsafe是安全的：

• cur_slice始终指向full的堆内存（Vec移动时堆内存地址不变）
• 迭代器存活期间full不会被修改或销毁
• 每次next仅修改指针范围，不存在数据竞争

3. Nightly下使用GAT实现标准Lending Iterator #

开启generic_associated_types特性（Rust 1.65+ nightly），实现符合标准设计的借出迭代器：

#![feature(generic_associated_types)]

// 标准风格的借出迭代器 trait
trait LendingIterator {
    type Item<'a> where Self: 'a;
    fn next(&mut self) -> Option<Self::Item<'_>>;
}

struct Slicer {
    full: Vec<u32>,
    end_idx: usize,
}

impl Slicer {
    fn new() -> Self {
        let full = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
        Slicer {
            full,
            end_idx: full.len(),
        }
    }
}

impl LendingIterator for Slicer {
    type Item<'a> = &'a [u32] where Self: 'a;

    fn next(&mut self) -> Option<Self::Item<'_>> {
        if self.end_idx == 0 {
            None
        } else {
            self.end_idx -= 1;
            Some(&self.full[0..self.end_idx])
        }
    }
}

fn main() {
    let mut slicer = Slicer::new();
    while let Some(slice) = slicer.next() {
        println!("{slice:?}");
    }
}

这种方法可以结合未来稳定的GAT特性，实现类型安全的借出迭代器，是长期的最佳方案。

4. 使用第三方库（稳定版） #

使用lending-iterator或async-trait等第三方库，在稳定版Rust中实现借出迭代器，无需手动处理unsafe或nightly特性。

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