如何在Rust中实现C++风格的浮点数for循环？

当然可以实现，下面提供几种贴合你需求的方案：

方案1：借助itertools库的successors迭代器 #

这是最简洁的实现方式，只需引入itertools crate：

use itertools::Itertools;

fn main() {
    let threshold = 10.0;
    let step_size = 0.5;

    // 一行定义循环的起始、步长和终止条件
    for t in successors(Some(0.0), |&prev| {
        let next = prev + step_size;
        (next < threshold).then_some(next)
    }) {
        // 循环体逻辑
        println!("t = {}", t);
    }
}

该方案完全匹配你的需求：

• 循环核心逻辑（起始值、步长、终止条件）紧凑集中，一目了然
• 更新逻辑和终止条件绑定在一起，无需在大循环体末尾查找
• 变量t仅在循环作用域内有效

方案2：自定义迭代器（无第三方依赖） #

如果不想引入外部库，可以手动实现一个浮点数范围迭代器：

// 定义迭代器结构体
struct FloatRange {
    current: f32,
    threshold: f32,
    step: f32,
}

impl Iterator for FloatRange {
    type Item = f32;

    fn next(&mut self) -> Option<Self::Item> {
        if self.current >= self.threshold {
            return None;
        }
        let val = self.current;
        self.current += self.step;
        Some(val)
    }
}

// 封装构造函数，简化调用
fn float_range(start: f32, threshold: f32, step: f32) -> FloatRange {
    FloatRange {
        current: start,
        threshold,
        step,
    }
}

fn main() {
    // 调用方式和C++的for循环逻辑对齐
    for t in float_range(0.0, 10.0, 0.5) {
        println!("t = {}", t);
    }
}

这个方案的优势是完全可控，循环逻辑通过float_range的参数清晰传递，所有循环相关变量都被封装在迭代器内部，不会污染外部作用域。

方案3：用loop模拟（原生语法） #

如果偏好纯原生语法，也可以用loop配合条件判断模拟，但更新语句仍需放在循环体末尾：

fn main() {
    let threshold = 10.0;
    let step_size = 0.5;

    let mut t = 0.0;
    loop {
        if !(t < threshold) {
            break;
        }
        // 循环体逻辑
        println!("t = {}", t);
        t += step_size;
    }
}

这种方式虽然满足变量作用域的要求，但更新语句位置的问题依然存在，适合对第三方库有顾虑的场景。

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