可以在表达式中结合赋值和比较吗？

Question

在 C 中，通常在单个表达式中进行赋值和比较：

n = n_init;
do {
    func(n);
} while ((n = n.next) != n_init);

据我了解，这可以用 Rust 表示为：

n = n_init;
loop {
    func(n);
    n = n.next;
    if n == n_init {
        break;
    }
}

这与 C 版本的工作方式相同（假设循环体不使用continue）。

在 Rust 中是否有更简洁的方式来表达这一点，或者上面的示例是否理想？

就本问题而言，假设所有权或满足借用检查器不是问题。满足这些要求取决于开发人员。

例如，作为整数：

n = n_init;
loop {
    func(&vec[n]);
    n = vec[n].next;
    if n == n_init {
        break;
    }
}

这似乎很明显，Rust 示例是惯用的 Rust - 但是我希望将相当多的这种循环风格转移到 Rust，我很想知道是否有更好/不同的方式来表达它.

Answer 1

在 Rust 中表示迭代的惯用方式是使用 Iterator。因此，您将实现一个执行 n = n.next 的迭代器，然后使用 for 循环来迭代该迭代器。

struct MyIter<'a> {
    pos: &'a MyData,
    start: &'a MyData,
}
impl<'a> Iterator for MyIter<'a> {
    type Item = &'a MyData;
    fn next(&mut self) -> Option<&'a MyData> {
        if self.pos as *const _ == self.start as *const _ {
            None
        } else {
            let pos = self.pos;
            self.pos = self.pos.next;
            Some(pos)
        }
    }
}

将这个迭代器调整为能够从第一个元素开始而不是从第二个元素开始，留给读者作为练习。

Answer 2

Rust 支持 if 和 while 中的模式匹配：

• 如果模式匹配，则认为测试成功，而不是布尔条件
• 作为模式匹配的一部分，您将匹配的值绑定到名称

因此，如果您构建的不是布尔条件，而是 Option...

fn check(next: *mut Node, init: *mut Node) -> Option<*mut Node>;

let mut n = n_init;
loop {
    func(n);
    if let Some(x) = check(n.next, n_init) {
        n = x;
    } else {
        break;
    }
}

但是，如果您可以使用 Iterator 代替，您会更加惯用。

Answer 3

Rust 中的赋值返回空元组。如果你对非惯用代码没问题，你可以将赋值结果与这样一个空元组进行比较，并使用逻辑连接来链接你的实际循环条件。

let mut current = 3;
let mut parent;

while (parent = get_parent(current)) == () && parent != current {
    println!("currently {}, parent is {}", current, parent);
    current = parent;
}

// example function
fn get_parent(x: usize) -> usize {
    if x > 0 { x - 1 } else { x }
}

// currently 3, parent is 2
// currently 2, parent is 1
// currently 1, parent is 0

这样做的缺点是进入循环需要运行逻辑（你可以使用 C 的do {..} while(); 样式循环来避免）。

您可以在 do-while 宏中使用这种方法，但可读性不是很好，此时重构可能更可取。无论如何，这就是它的样子：

do_it!({
    println!("{}", n);
} while (n = n + 1) == () && n < 4);

这是宏的代码：

macro_rules! do_it {
    ($b: block while $e:expr) => {
        loop {
            $b
            if !($e) { break };
        }
    }
}