Reflexionen über die Programmiersprache Rust 13

Schleifen
3. Loop

Im Prinzip schon angekündigt, wird sich das Schleifenthema als Haupttrakt mit diesem Abschnitt beenden. Loop ist eine Endlosschleife und kann nur durch ein gezieltes Break abgebrochen werden. Es reicht vollkommen aus, den Inhalt von loop in geschweifte Klammern zu setzen und schon hört es nicht mehr auf.

fn main (){
    loop{
        print!("Endlosschleife - ");
    }
}

Ausgabe (Ausschnitt)

Das ist natürlich nicht übermäßig nützlich, zeigt aber verkürzt, wie es funktioniert. Was ist aber der Einsatzort einer solchen Loop-Schleife?
Kurz gesagt, kann man sie überall dort brauchen, wo ein Programm am Laufen gehalten werden soll. Obwohl ich keine Ahnung von der Entwicklung eines Betriebssystems habe, würde ich davon ausgehen, dass loop(s) hier nötig sind, denn ansonsten (nachdem in der Programmierung vorgesehen ist, dass es sich von oben nach unten durcharbeitet), wäre wohl schon bald Schluss, wenn die Basis nicht aufrechterhalten wird. Im Laufe der Zeit werde ich vermutlich auch vermehrt darauf zurückgreifen, aber bis jetzt schreibe ich noch nicht so große Programme, dass ich es brauchen würde ... Aber mal sehen, es ist gut, so etwas in petto zu haben.

Um auch auf die Iteration einzugehen

let mut x=0;
     loop{
         x=x+1;
        print!(" x: {} - ",x);
    }

Ausgabe (Ausschnitt)

Die Bandbreite des i32 fängt einfach immer wieder von vorne an. Wie bei der while true Schleife.

Eine nützliche Besonderheit der loop-Schleife möchte ich nicht vorenthalten. Diese lassen sich nämlich auch einen Namen geben. Einfach mit
'name_der_Schleife: loop;' Wenn mehrere loops am Laufen sind, können diese durch ihre Namen mit break 'name_der_Schleife abgebrochen werden.

    'loop_gesamt: loop{
        println!("Hier beginnen die Geschichten von x und y");
        let mut x =0;
        'loop_x: loop{

            x=x+1;
            if x <=10{
                 println!("{}. x geht noch weiter.",x);
            }
            else{
                println!("Das ist das Ende von x");
                break 'loop_x;
            }
        }

        let mut y =0;
        'loop_y: loop{

            y=y+1;
            if y <=10{
                 println!("{}. y geht noch weiter.",y);
            }
            else{
                println!("Das ist das Ende von y");
                break 'loop_y;
            }

        }

                println!("Das ist das Ende vom Lied von x und y");
                break 'loop_gesamt;

            }

Zugegeben, das sieht hier etwas viel aus. Es ist sogar anders, als ich ursprünglich gedacht habe. Bei diesem Beispiel habe ich selbst einiges dazu gelernt. Vor allem in welche Richtungen die Gedanken beim Programmieren laufen sollten.

*Entspricht das was ich will, dem was ich will?
*Weiß ich etwas nicht, oder ist die Methode falsch, die ich anwende?
*Wenn ich die richtige Methode anwende, warum funktioniert es nicht?
*Sind meine Annahmen über die Methode richtig?

Da gäbe es wahrscheinlich noch ein paar so ähnlich klingende Überlegungen, die allesamt ähnlich klingen, aber trotzdem für einen Zweck essentiell sind.

Also, was macht dieser Codeblock?

In Summe gibt es 3 Endlosschleifen, die per break mit dem jeweiligen Schleifennamen abgebrochen werden.

*loop_gesamt
*loop_x
*loop_y

loop_gesamt bricht ab, wenn die loops von x und y durchgelaufen sind. Im übrigen das letzte Break, darf nicht vor der println!-Anweisung stehen, sonst bekommt man diese nie vor Gesicht.

loop_x lauft bis 10, wird dann abgebrochen und geht weiter auf loop_y. Das widerrum bricht auch bei 10 ab und dadurch geht der Code zum Schleifende von loop_gesamt. Die Ausgabe sieht dann so aus:

Heute kann ich keine gesamte Ausgabe zeigen, weil Endlosschleifen logischerweise dafür nicht geeignet sind. Aber natürlich, wie mein Quellcode aussieht, obwohl er so nicht vernüftig ausführbar wäre.

fn main (){
    loop{
        print!("Endlosschleife - ");
    }
    let mut x=0;
     loop{
         x=x+1;
        print!(" x: {} - ",x);
    }


    'loop_gesamt: loop{
        println!("Hier beginnen die Geschichten von x und y");
        let mut x =0;
        'loop_x: loop{

            x=x+1;
            if x <=10{
                 println!("{}. x geht noch weiter.",x);
            }
            else{
                println!("Das ist das Ende von x");
                break 'loop_x;
            }
        }

        let mut y =0;
        'loop_y: loop{

            y=y+1;
            if y <=10{
                 println!("{}. y geht noch weiter.",y);
            }
            else{
                println!("Das ist das Ende von y");
                break 'loop_y;
            }

        }

                println!("Das ist das Ende vom Lied von x und y");
                break 'loop_gesamt;

            }

    }