ฉันจะทำซ้ำในช่วงด้วยขั้นตอนที่กำหนดเองได้อย่างไร

ฉันจะทำซ้ำในช่วงใน Rust ด้วยขั้นตอนอื่นที่ไม่ใช่ 1 ได้อย่างไร ฉันมาจากพื้นหลัง C ++ ดังนั้นฉันต้องการทำสิ่งที่ชอบ

for(auto i = 0; i <= n; i+=2) {
    //...
}

ใน Rust ฉันจำเป็นต้องใช้rangeฟังก์ชันนี้และดูเหมือนว่าจะไม่มีอาร์กิวเมนต์ที่สามสำหรับการมีขั้นตอนที่กำหนดเอง ฉันจะทำสิ่งนี้ให้สำเร็จได้อย่างไร?

range_step_inclusiveและrange_stepหายไปนาน

ณ สนิม 1.28 Iterator::step_byมีความเสถียร:

fn main() {
    for x in (1..10).step_by(2) {
        println!("{}", x);
    }
}

สำหรับฉันแล้วดูเหมือนว่าจนกว่า.step_byวิธีการนี้จะมีเสถียรภาพเราสามารถบรรลุสิ่งที่คุณต้องการได้อย่างง่ายดายด้วยIterator(ซึ่งก็คือสิ่งที่Rangeเป็นจริงอยู่ดี):

struct SimpleStepRange(isize, isize, isize);  // start, end, and step

impl Iterator for SimpleStepRange {
    type Item = isize;

    #[inline]
    fn next(&mut self) -> Option<isize> {
        if self.0 < self.1 {
            let v = self.0;
            self.0 = v + self.2;
            Some(v)
        } else {
            None
        }
    }
}

fn main() {
    for i in SimpleStepRange(0, 10, 2) {
        println!("{}", i);
    }
}

หากจำเป็นต้องวนซ้ำหลายช่วงของประเภทต่างๆโค้ดสามารถสร้างเป็นแบบทั่วไปได้ดังนี้:

use std::ops::Add;

struct StepRange<T>(T, T, T)
    where for<'a> &'a T: Add<&'a T, Output = T>,
          T: PartialOrd,
          T: Clone;

impl<T> Iterator for StepRange<T>
    where for<'a> &'a T: Add<&'a T, Output = T>,
          T: PartialOrd,
          T: Clone
{
    type Item = T;

    #[inline]
    fn next(&mut self) -> Option<T> {
        if self.0 < self.1 {
            let v = self.0.clone();
            self.0 = &v + &self.2;
            Some(v)
        } else {
            None
        }
    }
}

fn main() {
    for i in StepRange(0u64, 10u64, 2u64) {
        println!("{}", i);
    }
}

ฉันจะปล่อยให้คุณกำจัดการตรวจสอบขอบเขตด้านบนเพื่อสร้างโครงสร้างปลายเปิดหากต้องการลูปที่ไม่มีที่สิ้นสุด ...

ข้อดีของวิธีนี้คือใช้ได้กับการทำforน้ำตาลและจะยังคงทำงานต่อไปแม้ว่าจะใช้งานฟีเจอร์ที่ไม่เสถียรได้ก็ตาม ยังแตกต่างจากวิธีการลดน้ำตาลโดยใช้มาตรฐานRanges คือไม่สูญเสียประสิทธิภาพจากการ.next()โทรหลายครั้ง ข้อเสียคือต้องใช้โค้ดสองสามบรรทัดในการตั้งค่าตัววนซ้ำดังนั้นอาจคุ้มค่าสำหรับโค้ดที่มีการวนซ้ำมาก ๆ

ใช้NUMลังกับrange_step

คุณจะเขียนรหัส C ++ ของคุณ:

for (auto i = 0; i <= n; i += 2) {
    //...
}

... ใน Rust เป็นเช่นนั้น:

let mut i = 0;
while i <= n {
    // ...
    i += 2;
}

ฉันคิดว่าเวอร์ชั่น Rust ก็อ่านได้มากกว่าเช่นกัน

หากคุณกำลังก้าวตามสิ่งที่กำหนดไว้ล่วงหน้าและมีขนาดเล็กเช่น 2 คุณอาจต้องการใช้ตัววนซ้ำเพื่อทำตามขั้นตอนด้วยตนเอง เช่น:

let mut iter = 1..10;
loop {
    match iter.next() {
        Some(x) => {
            println!("{}", x);
        },
        None => break,
    }
    iter.next();
}

คุณยังสามารถใช้สิ่งนี้เพื่อทีละจำนวนตามอำเภอใจ (แม้ว่าจะนานขึ้นและย่อยยากขึ้น):

let mut iter = 1..10;
let step = 4;
loop {
    match iter.next() {
        Some(x) => {
            println!("{}", x);
        },
        None => break,
    }
    for _ in 0..step-1 {
        iter.next();
    }
}