Speaker A
Schleifen könnt ihr dazu verwenden, Programmteile wiederholt ausführen zu lassen und dafür gibt's drei verschiedene Schleifentypen, nämlich die Vorschleife, die Repeat Until Schleife und die While Schleife.
Dieses Video erklärt die drei Schleifentypen FOR, REPEAT und WHILE anhand praktischer SPS-Programmierungsbeispiele in Deutsch.
Key Takeaways
- Schleifen ermöglichen die wiederholte Ausführung von Programmteilen und sind essenziell für Algorithmen in SPS.
- Vorschleifen eignen sich gut für feste Wiederholungsanzahlen, z.B. beim Vertauschen von Array-Elementen.
- Repeat Until Schleifen sind ideal für Abläufe, die bis zu einer Bedingung wiederholt werden müssen, z.B. Bubble Sort.
- While Schleifen können für Algorithmen mit unbestimmter Wiederholungsanzahl verwendet werden, z.B. Euklidischer Algorithmus.
- Die korrekte Übergabe und Handhabung von Arrays mit variabler Länge ist wichtig für flexible Funktionen.
Summary
- Vorstellung der drei Schleifentypen: Vorschleife (FOR), Repeat Until Schleife und While Schleife.
- Erstes Beispiel: Vertauschen von Array-Elementen mit der Vorschleife.
- Erklärung der Übergabe von Arrays an Funktionen mit variabler Länge.
- Zweites Beispiel: Implementierung des Bubble Sort Algorithmus mit einer Repeat Until Schleife.
- Detaillierte Erläuterung des Programmablaufplans für Bubble Sort.
- Drittes Beispiel: Berechnung des größten gemeinsamen Teilers mit dem Euklidischen Algorithmus und der While Schleife.
- Praktische Demonstrationen und Tests der Funktionen im SPS-Programm.
- Hinweise zur Syntax und Besonderheiten der Schleifen in SPS-Programmierung.
- Erklärung von Variablen und Zwischenspeicherung bei Elementtausch.
- Betonung der Bedeutung von Schleifen für wiederholte Programmausführung.
Full Transcript — Download SRT & Markdown
Speaker A
Und hier zeige ich euch am Beispiel von drei sinnvollen Algorithmen, wie man diese Schleifen verwendet. Im ersten Beispiel geht's um die Vorschleife, die ich einsetzen werde, um die Elemente in einem Array zu vertauschen.
Speaker A
Im zweiten Beispiel zeige ich euch die Repeat Until Schleife und zwar am Beispiel eines sehr einfachen Sortieralgorithmus, das ist also ein Algorithmus, mit dem man die Elemente in einem Array aufsteigend sortieren kann.
Speaker A
Und das dritte Beispiel ist dann der Euklidische Algorithmus, bei dem ich die While Schleife einsetzen werde. Der Euklidische Algorithmus ist also ein Algorithmus, mit dem man den größten gemeinsamen Teiler zweier natürlicher Zahlen berechnen kann.
Speaker A
Okay, starten wir mit der Vorschleife und dem Vertauschen der Elemente in einem Array, z.B. von diesem hier.
Speaker A
Das Vertauschen der Reihenfolge implementiere ich jetzt in dieser Funktion hier.
Speaker A
Der Eingabeparameter ist das Array, bei dem die Elemente vertauscht werden.
Speaker A
Im Video zu Arrays habe ich euch schon erklärt, dass ich das Array in diesem Var In Out Block übergeben muss,
Speaker A
damit die Vertauschung in dem übergebenen Array und nicht in einer Kopie davon gemacht wird.
Speaker A
So und dann brauche ich noch Hilfsvariablen, nämlich einmal einen Schleifenzähler für die Vorschleife.
Speaker A
Und dann noch diese Hilfsvariablen, die ich zum Zwischenspeichern der zu tauschenden Elemente benutze.
Speaker A
So, zum Vertauschen der Elemente nehme ich jetzt das erste Element
Speaker A
und speichere das in N Buff zwischen.
Speaker A
Dann überschreibe ich das erste Element mit dem letzten Element.
Speaker A
Und am Ende überschreibe ich das letzte Element mit dem Wert aus N Buff.
Speaker A
Dann habe ich das erste und das letzte Element vertauscht.
Speaker A
Das Ganze kann ich jetzt noch mal mit dem zweiten und dem vorletzten Element machen.
Speaker A
Und hier seht ihr schon, dass sich der gleiche Code wiederholt, nur mit anderen Indizes.
Speaker A
Da wir die Länge unseres Arrays kennen, wissen wir auch, wie häufig wir diesen Code wiederholen müssen, um alle Elemente des Arrays zu vertauschen,
Speaker A
nämlich in diesem Beispiel hier dreimal.
Speaker A
Für solche Wiederholungen mit fester Wiederholungsanzahl gibt's eben die Vorschleife.
Speaker A
In dieser Vorschleife werden jetzt also diese drei Codezeilen wiederholt ausgeführt.
Speaker A
Die Wiederholungsanzahl wird hier im Schleifenkopf festgelegt.
Speaker A
Die Schleife startet mit I = 0 und dann wird der Code ausgeführt.
Speaker A
Anschließend wird I um den Wert erhöht, der hier hinter dem By steht, also um 1.
Speaker A
Und dann wird geprüft, ob I noch kleiner oder gleich dem Wert hinter dem To ist.
Speaker A
Wenn das der Fall ist, wird die Schleife wieder ausgeführt.
Speaker A
Nach dem dritten Durchlauf wird I auf 3 gesetzt und dann ist die Bedingung für das Ausführen der Schleife also nicht mehr erfüllt.
Speaker A
Und die Schleife wird abgebrochen und die Elemente im Array sind komplett vertauscht.
Speaker A
So, diese Funktion teste ich jetzt.
Speaker A
Und dafür rufe ich die Funktion aus dem Main Programm auf.
Speaker A
So, jetzt starte ich das Programm.
Speaker A
Und dann seht ihr hier, dass das Array umgedreht wird, wenn B Flip auf True gesetzt wird.
Speaker A
In der Vorschleife hier ist die Angabe von By übrigens nur dann nötig,
Speaker A
wenn die Veränderung des Schleifenzählers I um einen anderen Wert als 1 verändert wird.
Speaker A
Das heißt, wenn ich By 1 weglasse, wird implizit angenommen, dass nach jedem Schleifendurchlauf I um den Wert 1 erhöht wird.
Speaker A
So, die Funktion macht ja schon das Richtige.
Speaker A
Allerdings nur für Arrays der Länge 6.
Speaker A
Wenn ich im Main Programm jetzt ein längeres oder auch kürzeres Array hätte, würde die Funktion nicht funktionieren.
Speaker A
Im Video zu den Arrays habe ich euch auch schon gezeigt, wie man Arrays variabler Länge an Funktionen übergeben kann,
Speaker A
nämlich, indem ich die Grenzen hier oben durch ein Sternchen ersetze.
Speaker A
So, dann muss ich noch die Indizes im Anweisungsteil anpassen.
Speaker A
Und dazu erstelle ich mir zunächst noch mal zwei Variablen, in denen ich die untere und die obere Grenze des Arrays speicher.
Speaker A
Und dann setze ich diese Grenzen hier in der Schleife und in den Zugriffen auf das Array ein.
Speaker A
So, jetzt sollte die Funktion Flip für eindimensionale Arrays mit beliebiger Größe und beliebig festgelegtem Bereich für den Index funktionieren.
Speaker A
Dass das auch so ist, teste ich jetzt einmal mit diesem Array hier.
Speaker A
Und hier im Online Modus seht ihr jetzt wieder, dass die Funktion korrekt funktioniert.
Speaker A
Im zweiten Beispiel, dass ich euch hier zeige, werde ich den Bubble Sort Algorithmus implementieren.
Speaker A
Das ist ein sehr einfacher Sortieralgorithmus, der allerdings nicht besonders effizient ist und daher in der Praxis auch kaum eingesetzt wird.
Speaker A
Aber an diesem Beispiel kann ich euch die Verwendung einer Repeat Until Schleife ganz gut erklären.
Speaker A
So, zuerst möchte ich euch den Algorithmus anhand dieses Programmablaufplans kurz erläutern.
Speaker A
Nach dem Start wird also zunächst eine Integer Variable N Fixed auf 1 gesetzt.
Speaker A
Für das Sortieren des Arrays wird dieses nämlich mehrmals durchlaufen und diese Variable N Fixed hier,
Speaker A
gibt im Prinzip an, wie viele Werte nach jedem Durchlauf schon an der richtigen Position stehen.
Speaker A
So und dann wird eine Bool Variable B Swapped auf False gesetzt.
Speaker A
Und in dieser Variablen wird gespeichert, ob beim Durchlaufen des Arrays eine Vertauschung überhaupt vorgenommen werden musste oder nicht.
Speaker A
So, dieser ganze Teil hier beschreibt eine Vorschleife mit der Zählervariablen I,
Speaker A
die hier zunächst auf den untersten Index des Arrays gesetzt wird.
Speaker A
Und dann wird geprüft, ob die Zählervariable diese Bedingung hier erfüllt.
Speaker A
Und wenn das der Fall ist, wird geprüft, ob das Array Element mit dem Index I
Speaker A
größer als das nachfolgende Element ist.
Speaker A
Dann muss eine Vertauschung vorgenommen werden und B Swapped wird auf True gesetzt.
Speaker A
Wenn aber die Bedingung nicht erfüllt ist, dann passiert in der Vorschleife nichts.
Speaker A
Und es wird nur der Schleifenzähler inkrementiert.
Speaker A
So, wenn die Vorschleife dann vollständig abgearbeitet wurde,
Speaker A
wird N Fixed inkrementiert.
Speaker A
Und dann wird geschaut, ob B Swapped den Wert False hat.
Speaker A
Ist das nicht der Fall, muss also eine Vertauschung vorgenommen worden sein.
Speaker A
Und der Algorithmus setzt wieder hier oben ein.
Speaker A
Anderenfalls ist das Array komplett sortiert und der Algorithmus wird beendet.
Speaker A
Okay, jetzt habe ich grob den Ablauf des Algorithmus erklärt.
Speaker A
Und dabei habt ihr gesehen, dass darin auch eine Vorschleife vorkommt.
Speaker A
Aber ich wollte euch ja eigentlich hier ran die Repeat Until Schleife erklären.
Speaker A
So und die steckt hier.
Speaker A
Dieser ganze Bereich wird also wiederholt so oft ausgeführt, bis die Bedingung B Swapped gleich False erfüllt ist.
Speaker A
So, diesen Algorithmus implementiere ich jetzt in dieser Funktion Fun Sort.
Speaker A
Im Deklarationsteil deklariere ich das Array, dessen Elemente sortiert werden sollen.
Speaker A
Und zwar mit variabler Länge.
Speaker A
Und dann brauche ich noch die Variablen N Fixed, die ich gleich mit dem Wert 1 initialisiere.
Speaker A
Und dann noch B Swapped und den Schleifenzähler I.
Speaker A
Für das Vertauschen von Elementen brauche ich gleich noch, genau schon wie beim vorherigen Beispiel, eine Buffer Variable N Buffer.
Speaker A
Im Anweisungsteil beginne ich dann mit der Repeat Until Schleife.
Speaker A
Die wird also mit dem Schlüsselwort Repeat eingeleitet und mit End Repeat beendet.
Speaker A
Und hier zwischen dem Until und dem End Repeat kommt dann die Abbruchbedingung der Schleife.
Speaker A
Und das ist in diesem Beispiel B Swapped gleich False.
Speaker A
Oder anders ausgedrückt, Not B Swapped.
Speaker A
Wichtig ist hier, dass diese Bedingung keine Anweisung ist und daher nicht mit einem Semikolon beendet wird.
Speaker A
So, der Schleifenrumpf steht dann hier oben.
Speaker A
Hier wird als erstes B Swapped auf False gesetzt.
Speaker A
Und dann kommt die Vorschleife.
Speaker A
In der Vorschleife wird dann die Abfrage gemacht, ob das Element mit Index I größer als das nachfolgende Element ist.
Speaker A
Und wenn das der Fall ist, kommt dann die Vertauschung der Elemente.
Speaker A
Und B Swapped wird auf True gesetzt.
Speaker A
Nach der Vorschleife wird N Fixed um 1 erhöht.
Speaker A
Und dann ist der Bubble Sort auch schon vollständig implementiert.
Speaker A
So, jetzt teste ich einmal diese Funktion.
Speaker A
Und dazu gehe ich wieder in das Main Programm.
Speaker A
Und deklariere hier ein Array und initialisiere das so, dass es auch hier etwas zu sortieren gibt.
Speaker A
Und das Startsignal zum Sortieren nenne ich dann auch noch passend B Sort.
Speaker A
Im Anweisungsteil rufe ich dann noch Fun Sort auf.
Speaker A
Und dann lasse ich das Programm laufen.
Speaker A
So und im Online Modus seht ihr jetzt also, dass das Sortieren des Arrays geklappt hat.
Speaker A
Im dritten Beispiel zeige ich euch jetzt noch die Verwendung der While Schleife.
Speaker A
Und das mache ich an einem wirklich einfachen Algorithmus, nämlich dem Euklidischen Algorithmus,
Speaker A
mit dem man den größten gemeinsamen Teiler zweier natürlicher Zahlen berechnen kann.
Speaker A
Den Algorithmus seht ihr hier wieder als Programmablaufplan.
Speaker A
Die Zahlen, deren größten gemeinsamen Teiler also berechnet werden soll, sind hier A und B.
Speaker A
Solange B ungleich 0 ist, werden diese Berechnung hier durchgeführt.
Speaker A
Da wird also einer Hilfsvariablen H das Ergebnis der Modulo Operation von A und B zugewiesen.
Speaker A
Und A wird dann auf den Wert von B gesetzt und B auf den Wert von H.
Speaker A
Und wenn diese Bedingung dann hier nicht mehr erfüllt ist, ist der Algorithmus beendet.
Speaker A
Und das Ergebnis, also der größte gemeinsame Teiler der eingegebenen Zahlen A und B,
Speaker A
steht dann in der Variablen A.
Speaker A
So, diese Bedingung zusammen mit diesem Anweisungsblock ist also eine While Schleife.
Speaker A
Damit steige ich jetzt wieder in die Implementierung.
Speaker A
Und dazu verwende ich diese Funktion Fun GGT.
Speaker A
Die Input Variablen sind die Zahlen A und B und zudem deklariere ich hier noch die Hilfsvariable H.
Speaker A
Und im Anweisungsteil steht dann fast nur die While Schleife.
Speaker A
Die Syntax der While Schleife steht hier, die wird also durch das Schlüsselwort While eingeleitet,
Speaker A
gefolgt von der Bedingung, unter der die Schleife ausgeführt werden soll.
Speaker A
Und beendet wird die Schleife mit End While.
Speaker A
Und im Schleifenrumpf stehen dann diese Anweisung, wie schon im Programmablaufplan erklärt.
Speaker A
Und wenn die Schleife abgearbeitet ist, wird der Wert A zurückgegeben.
Speaker A
So, diese Funktion teste ich jetzt auch wieder im Main Programm.
Speaker A
Und dazu deklariere ich zunächst zwei Zahlen, deren größten gemeinsamen Teiler ich jetzt berechnen möchte.
Speaker A
Und initialisiere die mit diesen Werten hier.
Speaker A
Und dann deklariere ich noch eine Ergebnisvariable N GGT und eine Bool Variable B Run,
Speaker A
mit der ich wieder die Funktion starte.
Speaker A
Im Anweisungsteil rufe ich die Funktion dann auf.
Speaker A
Und dann geht's wieder los.
Speaker A
Im Online Modus seht ihr jetzt das Ergebnis.
Speaker A
Der größte gemeinsame Teiler von 132 und 187 ist also 11.
Speaker A
So, ich habe euch hier also an drei Beispielen gezeigt, wie die Vorschleife, die Repeat Until Schleife,
Speaker A
und die While Schleife funktionieren.
Speaker A
Noch mal zur Erinnerung, eine Vorschleife ist also eine Schleife mit einer festen Wiederholungsanzahl.
Speaker A
Eine Repeat Until Schleife ist eine Fußgesteuerte Schleife, die wird also so oft ausgeführt,
Speaker A
bis diese Abbruchbedingung, die am Ende der Schleife geprüft wird, wahr ist.
Speaker A
Und eine While Schleife ist eine Kopfgesteuerte Schleife.
Speaker A
Die wird also so lange ausgeführt, bis diese Bedingung, die vor der Schleife geprüft wird, wahr ist.
Speaker A
In jedem dieser Schleifentypen gibt es also eine Bedingung, unter der die Schleifen ausgeführt werden.
Speaker A
Es gibt aber noch zwei weitere Möglichkeiten, die Ausführung dieser Schleifen zu steuern.
Speaker A
Zum ersten ist das die Continue Anweisung.
Speaker A
Wenn die ausgeführt wird, wird der aktuelle Schleifendurchlauf abgebrochen.
Speaker A
Und es wird mit dem nächsten Schleifendurchlauf fortgefahren.
Speaker A
Und dann gibt es noch die Exit Anweisung.
Speaker A
Und damit wird dann die gesamte Schleife ungeachtet aller anderen Bedingungen beendet.
Topics:SPS ProgrammierungSchleifenFOR SchleifeREPEAT UNTIL SchleifeWHILE SchleifeArray vertauschenBubble SortEuklidischer AlgorithmusAutomatisierungProgrammierung
