Reference 从您自己的迭代器返回可变引用的简单示例

是相关的，但是它更详细地涵盖了编译器在从

Iterator:：next

返回可变引用时无法推断安全生存期的原因，我想我理解这一点

我的问题是:

在设计自己的迭代器以便生成可变引用时，可以采取哪些具体步骤？最后，我希望能有一个尽可能简洁、循序渐进、有注释的

迭代器及其
next
实现示例，当我（和任何人）遇到这种情况时，都可以作为一个清晰的参考<代码>不安全

示例很好，我想它们可能是必需的

---

注意：我知道这通常是推荐的示例，但是它的实现可能很难遵循，因为没有关于1的任何文档。标记在这种情况下是如何工作的以及2。什么是

迭代器宏”将扩展到及其工作方式。如果您使用
多项
作为示例，您能澄清一下这些问题吗？
下面是一种在假设的
点
结构上使用可变迭代器的方法。我发现用类似的方式对每个
不安全的
块进行注释非常有用，因为我只有在出错的情况下才会对自己的脚开枪

Rust编译器不知道每次提升迭代器时都会得到不同的可变引用。这个
不安全的
块是安全的，因为程序员保证这个迭代器不能两次返回同一个可变引用，或者允许任何其他方式到达同一地址

#[derive(Debug)]
struct Point {
    x: u8,
    y: u8,
    z: u8,
}

impl Point {
    fn iter_mut(&mut self) -> IterMut {
        IterMut {
            point: self,
            idx: 0,
        }
    }
}

struct IterMut<'a> {
    point: &'a mut Point,
    idx: u8,
}

impl<'a> Iterator for IterMut<'a> {
    type Item = &'a mut u8;

    fn next(&mut self) -> Option<&'a mut u8> {
        let retval = match self.idx {
            0 => &mut self.point.x,
            1 => &mut self.point.y,
            2 => &mut self.point.z,
            _ => return None,
        };

        self.idx += 1;

        // I copied this code from Stack Overflow without paying attention to
        // the prose which described why this code is actually safe.
        unsafe { Some(&mut *(retval as *mut u8)) }
    }
}

fn main() {
    let mut p1 = Point { x: 1, y: 2, z: 3 };

    for x in p1.iter_mut() {
        *x += 1;
    }

    println!("{:?}", p1);
}

#[派生（调试）]
结构点{
x:u8，
y:u8，
z:u8，
}
内点{
fn iter_mut（&mut self）->IterMut{
伊特穆特{
要点：自我，
idx:0，
}
}
}
结构IterMut{
类型项=&'a mut u8；
fn next（&mut self）->选项文件中的
迭代器
宏就在前面一点：谢谢！我在自己的用例中完成了这项工作。对于任何不确定
transmute
的功能的人，这里是其行为的总结，“不安全地将一种类型的值转换为另一种类型的值。”在这种情况下，transmute会推断正确的返回类型，同时确保借用检查器可变借用是安全的。