如何为含多可迭代对象的Rust结构体实现值与引用迭代

首先需要指出原代码中的两个关键问题：

1. as是Rust的关键字，不能用作结构体字段名，需改为a_slice这类合法名称；
2. 原MySet的字段是Box<[int]>，而MyElement的字段是Box<int>，这会导致：
   • into_iter无法避免复制（需把切片里的int包装成Box<int>，int是Copy类型必然复制）；
   • iter无法直接产出&MyElement（MySet中没有存储Box<int>，无法构造&Box<int>来组成&MyElement）。

因此我们先修正MySet的定义，让它存储Box<int>的切片，这样才能满足“不克隆/复制”的要求（注：Rust 1.0+已不再使用int，改用明确的i32/i64类型）：

pub struct MyElement {
    a: Box<i32>,
    b: Box<i32>,
}

pub struct MySet {
    a_slice: Box<[Box<i32>]>,
    b_slice: Box<[Box<i32>]>,
}

1. 实现MySet.into_iter()（消耗型迭代器，产出MyElement） #

为MySet实现IntoIterator trait，通过将两个切片的迭代器zip，直接移动Box<i32>构造MyElement，全程无克隆/复制：

impl IntoIterator for MySet {
    type Item = MyElement;
    type IntoIter = impl Iterator<Item = Self::Item>;

    fn into_iter(self) -> Self::IntoIter {
        // 将Box<[Box<i32>]>转为Vec的消耗型迭代器，直接移动元素
        let a_iter = self.a_slice.into_vec().into_iter();
        let b_iter = self.b_slice.into_vec().into_iter();
        
        // zip两个迭代器，将每对Box<i32>组合成MyElement
        a_iter.zip(b_iter).map(|(a, b)| MyElement { a, b })
    }
}

使用示例：

fn main() {
    let set = MySet {
        a_slice: Box::from([Box::new(1), Box::new(2), Box::new(3)]),
        b_slice: Box::from([Box::new(4), Box::new(5), Box::new(6)]),
    };

    for elem in set {
        println!("a: {}, b: {}", elem.a, elem.b);
    }
}

2. 实现MySet.iter()（借用型迭代器，产出&MyElement） #

由于MySet中没有直接存储MyElement实例，我们需要自定义迭代器，通过索引访问两个切片的对应元素，构造临时的MyElement引用。这里使用unsafe绕过Rust的借用检查（我们能保证引用的生命周期与MySet一致）：

// 自定义借用型迭代器
pub struct MySetIter<'a> {
    set: &'a MySet,
    index: usize,
}

impl<'a> Iterator for MySetIter<'a> {
    type Item = &'a MyElement;

    fn next(&mut self) -> Option<Self::Item> {
        // 检查索引是否超出任意一个切片的长度
        if self.index >= self.set.a_slice.len() || self.index >= self.set.b_slice.len() {
            return None;
        }

        // 构造临时MyElement，再将其转为&MyElement（unsafe保证生命周期安全）
        let elem = unsafe {
            let temp_elem = MyElement {
                a: &self.set.a_slice[self.index],
                b: &self.set.b_slice[self.index],
            };
            // 转换指针类型并调整生命周期，确保引用与迭代器绑定
            &*(std::ptr::addr_of!(temp_elem) as *const MyElement)
        };

        self.index += 1;
        Some(elem)
    }

    // 提供size_hint帮助迭代器优化
    fn size_hint(&self) -> (usize, Option<usize>) {
        let remaining = std::cmp::min(self.set.a_slice.len(), self.set.b_slice.len()) - self.index;
        (remaining, Some(remaining))
    }
}

// 为MySet添加iter方法
impl MySet {
    pub fn iter(&self) -> MySetIter<'_> {
        MySetIter {
            set: self,
            index: 0,
        }
    }
}

使用示例：

fn main() {
    let set = MySet {
        a_slice: Box::from([Box::new(1), Box::new(2), Box::new(3)]),
        b_slice: Box::from([Box::new(4), Box::new(5), Box::new(6)]),
    };

    for elem in set.iter() {
        println!("a: {}, b: {}", elem.a, elem.b);
    }
}

若坚持使用原MySet定义（Box<[int]>）的替代方案 #

如果必须保持原MySet的字段类型（存储int切片），则无法严格满足“不克隆/复制”的要求，但可以实现类似功能：

• into_iter：需将int复制到Box<int>中（int是Copy类型，无法避免）；
• iter：无法产出&MyElement，只能产出自定义的引用类型，例如：

pub struct MyElementRef<'a> {
    a: &'a i32,
    b: &'a i32,
}

impl MySet {
    pub fn iter(&self) -> impl Iterator<Item = MyElementRef<'_>> {
        self.a_slice.iter().zip(self.b_slice.iter()).map(|(a, b)| MyElementRef { a, b })
    }
}

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