Wie iteriere ich mit einem benutzerdefinierten Schritt über einen Bereich?

Wie kann ich mit einem anderen Schritt als 1 über einen Bereich in Rust iterieren? Ich komme aus einem C ++ - Hintergrund, also würde ich gerne so etwas machen

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

In Rust muss ich die rangeFunktion verwenden, und es scheint nicht, dass ein drittes Argument für einen benutzerdefinierten Schritt verfügbar ist. Wie kann ich das erreichen?

range_step_inclusiveund range_stepsind schon lange weg.

Ab Rust 1.28 Iterator::step_byist stabil:

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

Es scheint mir, dass man, bis die .step_byMethode stabil ist, leicht erreichen kann, was man will mit einem Iterator(was Rangeeigentlich sowieso ist):

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);
    }
}

Wenn mehrere Bereiche unterschiedlichen Typs iteriert werden müssen, kann der Code wie folgt generisch gestaltet werden:

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);
    }
}

Ich überlasse es Ihnen, die Prüfung der oberen Grenzen zu eliminieren, um eine Struktur mit offenem Ende zu erstellen, wenn eine Endlosschleife erforderlich ist ...

Der Vorteil dieses Ansatzes besteht darin, dass er mit forZucker arbeitet und auch dann weiter funktioniert, wenn instabile Funktionen verwendet werden können. Im Gegensatz zum Ansatz ohne Zucker, bei dem die Standards verwendet werden Range, geht die Effizienz bei mehreren .next()Anrufen nicht verloren . Nachteile sind, dass zum Einrichten des Iterators einige Codezeilen erforderlich sind. Dies lohnt sich möglicherweise nur für Code mit vielen Schleifen.

Sie würden Ihren C ++ - Code schreiben:

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

... in Rust so:

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

Ich denke, die Rust-Version ist auch besser lesbar.

Verwenden Sie die num Kiste mit range_step

Wenn Sie an etwas Vordefiniertem und Kleinem wie 2 vorbeikommen, möchten Sie möglicherweise den Iterator verwenden, um manuell zu treten. z.B:

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

Sie können dies sogar verwenden, um eine beliebige Menge zu erhöhen (obwohl dies definitiv länger und schwerer zu verdauen wird):

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();
    }
}