如何在结构字段上创建可变迭代器

一般来说，在可变引用上实现迭代器是很困难的。如果迭代器两次返回对同一元素的引用，则会变得不合理。这意味着，如果你想用纯安全的代码编写一个，你必须以某种方式说服编译器，每个元素只被访问一次。这排除了简单地使用索引：您可能总是忘记递增索引或将其设置在某个地方，编译器将无法对其进行推理。

一种可能的解决方法是将几个 s 链接在一起（每个引用对应一个要迭代的引用）。std::iter::once

例如

impl StatusRegister {
    fn iter_mut(&mut self) -> impl Iterator<Item = &mut bool> {
        use std::iter::once;
        once(&mut self.CarryFlag)
            .chain(once(&mut self.ZeroFlag))
            .chain(once(&mut self.OverflowFlag))
    }
}

（游乐场）

优点：

• 实现起来相当简单。
• 没有分配。
• 没有外部依赖关系。

缺点：

• 迭代器有一个非常复杂的类型：。std::iter::Chain<std::iter::Chain<std::iter::Once<&mut bool>, std::iter::Once<&mut bool>>, std::iter::Once<&mut bool>>

因此，如果您不想使用 ，则必须在代码中包含它。这包括实现 for ，因为您必须明确指示类型是什么。impl Iterator<Item = &mut bool>IntoIterator&mut StatusRegisterIntoIter

另一种方法是使用数组或保存所有可变引用（具有正确的生存期），然后委托给其迭代器实现以获取值。例如Vec

impl StatusRegister {
    fn iter_mut(&mut self) -> std::vec::IntoIter<&mut bool> {
        vec![
            &mut self.CarryFlag,
            &mut self.ZeroFlag,
            &mut self.OverflowFlag,
        ]
        .into_iter()
    }
}

（游乐场）

优点：

• 该类型更易于管理。std::vec::IntoIter<&mut bool>
• 实现起来仍然相当简单。
• 没有外部依赖关系。

缺点：

• 每次调用都需要分配。iter_mut

我还提到使用数组。这将避免分配，但事实证明，数组尚未在其值上实现迭代器，因此上面使用 a 而不是 a 的代码将不起作用。但是，存在为大小有限的固定长度数组实现此功能的板条箱，例如 arrayvec（或 array_vec）。[&mut bool; 3]Vec<&mut bool>

优点：

• 无分配。
• 简单的迭代器类型。
• 易于实现。

缺点：

• 外部依赖。

我要讨论的最后一种方法是使用 .由于与其他方法相比，这没有太多好处，因此我一般不推荐它。这主要是为了向您展示如何实现这一点。unsafe

与原始代码一样，我们将在自己的结构上实现。Iterator

impl<'a> IntoIterator for &'a mut StatusRegister {
    type IntoIter = StatusRegisterIterMut<'a>;
    type Item = &'a mut bool;

    fn into_iter(self) -> Self::IntoIter {
        StatusRegisterIterMut {
            status: self,
            index: 0,
        }
    }
}

pub struct StatusRegisterIterMut<'a> {
    status: &'a mut StatusRegister,
    index: usize,
}

不安全来自方法，我们必须（基本上）将类型转换为 ，这通常是不安全的。但是，只要我们确保不允许这些可变引用别名，我们应该没问题。可能还有其他一些微妙的问题，所以我不保证这是合理的。值得一提的是，MIRI没有发现任何问题。next&mut &mut T&mut Tnext

impl<'a> Iterator for StatusRegisterIterMut<'a> {
    type Item = &'a mut bool;

    // Invariant to keep: index is 0, 1, 2 or 3
    // Every call, this increments by one, capped at 3
    // index should never be 0 on two different calls
    // and similarly for 1 and 2.
    fn next(&mut self) -> Option<Self::Item> {
        let result = unsafe {
            match self.index {
                // Safety: Since each of these three branches are
                // executed exactly once, we hand out no more than one mutable reference
                // to each part of self.status
                // Since self.status is valid for 'a
                // Each partial borrow is also valid for 'a
                0 => &mut *(&mut self.status.CarryFlag as *mut _),
                1 => &mut *(&mut self.status.ZeroFlag as *mut _),
                2 => &mut *(&mut self.status.OverflowFlag as *mut _),
                _ => return None
            }
        };
        // If self.index isn't 0, 1 or 2, we'll have already returned
        // So this bumps us up to 1, 2 or 3.
        self.index += 1;
        Some(result)
    }
}

（游乐场）

优点：

• 没有分配。
• 简单的迭代器类型名称。
• 没有外部依赖关系。

缺点：

• 实施起来很复杂。要成功使用 ，您需要非常熟悉什么是允许的，什么是不允许的。到目前为止，这部分答案花了我最长的时间来确保我没有做错什么。unsafe
• 不安全因素会感染模块。在定义此迭代器的模块中，我可以通过弄乱 的 or 字段来“安全地”导致不健全。唯一允许封装的是，在此模块之外，这些字段是不可见的。statusindexStatusRegisterIterMut