Hallo und willkommen zurück.
Ich werde immer noch ein wenig über den Kontrollfluss sprechen.
Tauchen wir also direkt in Schleifen ein, in denen Code wiederholt wird.
Zuerst werden wir über diese for-Schleife sprechen.
In der for-Schleife dreht sich alles
um das Wiederholen von Code. Nur zur Erinnerung: Das Wiederholen von
Code ist eine Möglichkeit, keine Duplizierung zuzulassen,
und Sie führen möglicherweise tatsächlich mehr als einen ähnlichen Code gleichzeitig
aus.
Die Programmiersprache c verfügt also über bestimmte Konstrukte, die für die Sprache
entwickelt wurden, die Sie verwenden können, wenn Sie Code wiederholen möchten.
Auf diese Weise können Sie einen Anweisungsblock wiederholen, bis eine bestimmte Bedingung erfüllt ist.
Es ähnelt also der for-Schleife und Sie werden einen booleschen Ausdruck,
eine Bedingung, auswerten. Du kannst nicht für immer rennen.
Wenn Sie für immer in einer Schleife laufen, bedeutet dies, dass es sich um eine Endlosschleife handelt.
Und es gibt nur bestimmte Zeiten, in denen Sie
dies normalerweise noch einmal tun möchten, um etwas zu überwachen oder anzuhören.
Die Häufigkeit, mit der eine Schleife wiederholt wird, kann also einfach über das Konto gesteuert werden.
Es gibt zwei Arten von
Schleifen, die Sie ausführen können, eine Zählerregelschleife oder wie eine Sentinel-Regelschleife, wie sie es nennen.
Ein Zählerregelkreis bedeutet, dass der Regelkreis
10-mal, 20-mal, 30-mal und eine bestimmte Zeitspanne läuft.
Es wiederholt denselben Anweisungsblock innerhalb der
Schleife mehrmals.
Sie können eine andere Art von Schleife verwenden, bei der diese nicht gegengesteuert ist.
Es kann 5 Mal ausgeführt werden, es kann 100 Mal ausgeführt werden, es kann 20
Mal ausgeführt werden, alles hängt von einer Bedingung, einer Variablen oder etwas ab. So können Sie beispielsweise eine Schleife ausführen, die
besagt, dass ich meine Schleife immer und immer wieder ausführen werde, bis
der Benutzer quit beendet.
Also bis sich die Variable ändert, um zu beenden. Es ist nicht gegengesteuert. Es ist nicht abhängig.
Wieder kann es 10 Mal ausgeführt werden, es kann 100 Mal ausgeführt werden.
Dies sind die 2 verschiedenen Arten von Schleifen. Ich werde also Beispiele für beides
liefern, aber denken Sie nur auf hoher Ebene darüber nach, wann ich Code wiederholen möchte.
Nun, ich möchte vielleicht den Code fünfmal wiederholen, eine bestimmte Zeitspanne, eine definitive
Zeitspanne, oder ich möchte Code basierend auf einer
bestimmten Bedingung, die von einem Benutzer eingegeben wurde, einfügen, und das nennt man Sentinel.
Unsere for-Schleife hat das Schlüsselwort for. Es wird verwendet, um eine bestimmte
Anzahl von Malen auszuführen. Es wird normalerweise zur Gegensteuerung verwendet, muss es aber nicht sein.
Sie können es als Zählerregelkreis oder als Sentinel zum Regelkreis verwenden.
Es liegt an dir. Aber viele Beispiele in vielen
Bereichen der Praxis werden einige Male gegengesteuert.
Wenn Sie beispielsweise die Zahlen von 1 bis 10 anzeigen möchten, verwenden Sie die for-Schleife.
Sie möchten nicht 10 Codezeilen mit derselben
printf-Anweisung schreiben, in der eine andere Nummer angezeigt wird.
Das ist sehr ineffizient. Es ist sehr zeitaufwändig.
Sie würden eine for-Schleife verwenden, um Code zu wiederholen.
Was Sie tun würden, wäre, dass Sie so etwas tun würden.
Hier ist eine Einführung in die
for-Schleife, die Syntax.
Sie haben das Schlüsselwort for und dann diese Klammern.
Wiederum identifizieren die Klammern verschiedene Dinge, die für die for-Schleife
vor sich gehen.
Dann haben Sie eine Klammer und Sie haben Anweisungen in den Klammern.
Die Klammern stellen also wieder den Körper der
Schleife dar, genau wie die Klammern den Körper einer if-Anweisung.
Wenn Sie dort eine einzige Anweisung haben, benötigen Sie die Klammern nicht, aber es
empfiehlt sich, sie immer zu verwenden.
In diesem Beispiel sehen Sie hier das Schlüsselwort for, das als erstes identifiziert werden sollte.
Die Operation, wie lange sie ausgeführt wird, wird gesteuert und was zwischen den Klammern nach
dem Schlüsselwort for angezeigt wird, worauf wir näher eingehen werden.
Grundsätzlich gibt es dort 3 verschiedene Ausdrücke.
Und Sie können sie erkennen, weil sie durch das Semikolon getrennt sind.
Das Semikolon sagt also, dass dies eine Ausdrucksanweisung ist.
Also, was machen diese 3 Dinge, werden wir beschreiben.
Die Aktion, die Sie
wiederholen möchten, befindet sich im Körper der Schleife. Das passiert so oft.
In diesem Beispiel ist der Hauptteil der Schleife printf.
Wenn eine Bedingung als wahr ausgewertet wird, wird diese Zahl weiterhin gedruckt.
Bei einzelnen Anweisungen können Sie die geschweiften Klammern weglassen.
Lassen Sie uns dies im Detail durchgehen.
Das allgemeine Muster für die for-Schleife ist, dass Sie diese Art von Anweisung haben.
Sie haben ein für und dann haben Sie eine Startbedingung, dies ist Pseudocode.
Ich versuche hier die for-Schleife zu beschreiben.
Die Startbedingung ist also das Erste, alles vor dem ersten Semikolon.
Das zweite ist die Fortsetzungsbedingung mit einem
Semikolon am Ende, und das Letzte zwischen den Klammern ist die Aktion pro Iteration.
Und ich möchte jeden einzelnen davon beschreiben. Und danach ist im Körper die Schleifenanweisung.
Die Schleifenanweisung ist ziemlich einfach. Das ist nur im Körper.
Das ist der Code, der ausgeführt wird und der jedes Mal wiederholt wird.
Das ist ziemlich einfach.
Und wieder können Sie entweder Klammern unterbrechen, wenn Sie mehrere Anweisungen haben, oder die Klammern
weglassen, wenn Sie eine einzelne Anweisung haben.
Die Startbedingung, das erste, was in den Klammern
vor dem ersten Semikolon steht, ist normalerweise, aber nicht
immer, dass eine Variable initialisiert wird, die als Schleifensteuervariable bezeichnet wird.
Das ist die Variable, mit der Sie sich bei jeder Iteration befassen werden.
Die Regelungsvariable ist also in der Regel ein Zähler von irgendwann,
nicht immer wieder. Ich möchte betonen, dass dies nicht unbedingt
der Fall sein muss. Aber oft ist es in einer
for-Schleife ein Zähler und es wird verfolgt, wie oft die Schleife wiederholt wurde.
Das ist es, was diese Startbedingung und die Regelungsvariable tun.
Sie können hier auch mehrere Variablen desselben Typs deklarieren und initialisieren, wobei
die Deklaration durch Kommas getrennt ist. Sie können hier also mehrere Initialisierungsvariablen
verwenden.
Je nachdem, welchen c-Compiler Sie verwenden,
können Sie diese Variablen möglicherweise nicht in der for-Anweisung deklarieren.
Wenn Sie etwas unterhalb des C99-Compilers verwenden, müssen Sie
die Variablen außerhalb der for-Anweisung deklarieren und sie dann nur dort initialisieren, wo
die Startbedingung besagt, aber
wir werden einige dieser Beispiele durchgehen.
Die Ausgangsbedingung ist jedoch, wo Sie Variablen initialisieren.
Es ist die Regelkreisvariable und wird aus diesem Grund benannt, da sie steuert,
wie oft die Schleife ausgeführt wird, wenn Sie sie initialisieren.
Das nächste, worüber ich sprechen möchte, ist diese fortlaufende Bedingung, die Fortsetzungsbedingung, der Teil, der
vor dem nach diesem ersten Semikolon in der for-Schleife steht.
Dies ist ein logischer Ausdruck.
Dies ist die Bedingung, die als wahr oder falsch bewertet wird.
Dies ist, wenn Sie in die Schleife springen oder die Schleife verlassen.
Dies bestimmt, ob die Schleife weiterhin ausgeführt werden soll.
Solange diese Bedingung den Wert true hat, wird die Schleife weiter
ausgeführt, und alle Anweisungen im Body werden ausgeführt.
Dadurch wird normalerweise der Wert der Regelungsvariablen überprüft.
Sie initialisieren also die Regelungsvariable in der Startbedingung und
betrachten sie dann in der Fortsetzungsbedingung.
Sie können hier eine beliebige Logik oder einen beliebigen arithmetischen Ausdruck einfügen, solange Sie wissen, was Sie tun.
Die Fortsetzungsbedingung wird eher am Anfang der Schleife als am Ende getestet.
Dies wird als Vortestschleife bezeichnet.
Sie werden den Unterschied bemerken, wenn wir über die Do-While-Schleife sprechen, bei der es sich um eine Post-Test-Schleife handelt.
Dies bedeutet jedoch, dass die Schleifenanweisung einmal und 0 Mal
ausgeführt werden kann.
Es hängt alles davon ab, ob diese Fortsetzungsbedingung als wahr oder falsch bewertet wird oder nicht.
Wenn es als falsch ausgewertet wird, werden Sie den Body niemals ausführen.
Wenn es als wahr ausgewertet wird, führen Sie diesen Text mindestens einmal aus.
Die Aktion pro Iteration, die sich am Ende der for-Schleife nach dem zweiten
Semikolon befindet und normalerweise eine Art Modifikation der Schleifensteuervariablen vornimmt.
Es wird inkrementiert oder dekrementiert, wenn es sich um
einen Schleifenzähler handelt oder wenn es sich um eine Sentinel-Schleife handelt. Möglicherweise wird der Benutzer aufgefordert, weitere Eingaben einzugeben.
Sie können auch mehr als eine Änderung einer Variablen vornehmen.
Sie können die Regelungsvariable und andere Variablen ändern.
Sie müssen sie nur durch Kommas trennen.
Aber um alles zusammenzufassen, was
ich gesagt habe, haben wir diese kleine Tabelle, die das beschreibt.
Aber bevor wir darüber sprechen, schauen wir uns ein kleines Beispiel an.
Hier ist ein Beispiel. Wir haben das Schlüsselwort for.
Und dann werden Sie feststellen, dass int I gleich 1 j gleich
2 ist. Dort initialisieren wir Variablen.
Und wir initialisieren hier tatsächlich 2 durch Komma
getrennte Variablen, normalerweise in einer for-Schleife, normalerweise nur eine, die Regelungsvariable.
Aber in diesem Fall initialisieren wir I und j.
Und nach diesem Semikolon haben wir die Bedingung.
Wann werden wir eintreten und wann immer wir diese Schleife verlassen werden.
Wir werden eintreten, solange ich kleiner als 5 bin.
Das ist unser boolescher Ausdruck, der als wahr oder falsch ausgewertet wird.
Und nach diesem zweiten Semikolon
werden wir diese Regelungsvariable oder alle anderen Variablen, die wir betroffen haben, ändern.
Hier machen wir ein Plus plus I, dies
ist ein Inkrementierungsoperator, Präfix I. Und dann weisen wir j gleich j plus 2 zu.
Dies ist normalerweise Ihre x-Bedingung, wenn Sie
diese Regelungsvariable ändern.
Und dann hat der Körper der Schleife nur eine einzige Anweisung, sodass wir die Klammern nicht benötigen.
Wir drucken nur die Werte von I mal j aus.
Die von diesem Code erzeugte Ausgabe wird also
die Werte 2, 8, 18, 32 und 50 in einer einzelnen Zeile sein.
Die erste Iteration der Schleife, I wird gleich 1 sein, j wird gleich 2 sein.
Und so wird es I mal j sagen, was 1 mal 2 ist und es wird es anzeigen.
Es wird überprüft, ob ich nicht größer als 5 bin, ich bin nicht 1.
Also wird es wieder hochgehen und ein zweites Mal ausgeführt.
Und wir modifizieren auch diese Variable I in unserer letzten Anweisung.
In der zweiten Iteration der Schleife werde ich also gleich 2 sein.
Und j wird gleich 2 plus 2 sein, was 4 ist.
Jetzt multiplizieren wir also 2 mal 4, was 8 ist,
und wir werden es anzeigen und dann prüfen, ob ich
größer als 5 bin. Nein, ich bin immer noch 2.
Also modifizieren wir I so, dass es für die nächste Iteration gleich
3 ist, und wir modifizieren j so, dass es gleich 4 plus 2
ist, was 6 ist.
Und dann multiplizieren wir für die
dritte Iteration der Schleife I mal J. Also sagen wir 3 mal 6 und zeigen 18 an.
Bevor wir die vierte Iteration ausführen, prüfen wir, ob I größer als 5 ist.
Nein, es ist 4. Dann erhöhen wir es, wir sagen, es ist 5. Es ist gleich 5, also läuft es immer noch.
Dann machen wir 32 und dann 50.
Das ist also eine for-Anweisung. Sie möchten dies ausführen und im
Code-Browser ausführen und herumspielen und Dinge ändern.
Aber was wir hier tun, ist, dass wir drei verschiedene Dinge in einer einzigen Codezeile tun.
Wir initialisieren die Regelungsvariable oder andere Variablen.
Wir haben unseren booleschen Ausdruck nach unserem ersten Semikolon, unserer Ausgangsbedingung.
Und dann ändern wir die Regelungsvariable und alle anderen Variablen, die wir
als letzten Teil der for-Anweisung wünschen.
Um zusammenzufassen, was wir tun, habe ich dieses nette kleine handliche Diagramm
aus einem Buch gefunden und wollte es Ihnen zeigen. Dies fasst alles zusammen.
Dieses erste Semikolon initialisiert die Regelungsvariable.
Nach dem ersten Semikolon machen wir unsere Bedingung, unseren Booleschen Ausdruck.
Und nach dem zweiten
Semikolon ändern wir diese Regelungsvariable. Und dies ist das typische Beispiel, das Sie sehen.
Dies ist ein Zählerregelkreis, der bei 1 beginnt und bis 10 reicht.
Das wird also tatsächlich 10 Mal ausgeführt.
Der Schlüssel ist dort kleiner als gleich 10. Sie werden also relationale Operatoren als unsere Bedingungen sehen,
genau wie wir relationale Operatoren als unsere Bedingungen in unserer if-Anweisung gesehen haben.
Der Schlüssel hier ist, dass Sie diese Regelungsvariable ändern möchten oder niemals beenden werden.
Die Plus-Plus-Anzahl ist also sehr wichtig.
Und was die Inkrementierung vor oder nach der Inkrementierung betrifft, ob dieses Plus plus vor der
Variablen oder nach
der Variablen steht, müssen Sie sich keine
Sorgen machen, da es erst nach der Iteration der Schleife inkrementiert oder dekrementiert wird. Es spielt
keine Rolle, ob Sie plus plus zählen oder plus plus zählen.
Abhängig von der Version von c, die Sie für Ihren Compiler
ausführen, können Sie möglicherweise auch
die Anzahl der Variablen innerhalb der for-Schleife deklarieren, oder Sie müssen sagen, dass
int count gleich 1 oder in count außerhalb der for-Schleife und ist Initialisieren Sie es dann im ersten Semikolon.
C99 fügte die Initialisierung und Deklaration im selben
Teil der for-Schleife hinzu.
Aber so funktioniert die Schleife im Grunde.
Lassen Sie uns nun ein kleines Beispiel betrachten. Ich möchte Ihnen die Flexibilität der for-Schleife zeigen.
Hier ist ein Beispiel, in dem wir im Grunde nur einige ganze Zahlen summieren.
In diesem Beispiel werden wir den Benutzer bitten, eine Anzahl von Ganzzahlen einzugeben, die er summieren möchte.
Wir werden das in einer Variablen namens count speichern.
Wir werden jetzt eine for-Schleife haben, die alle diese
Schleifen durchläuft, abhängig von der Anzahl, die sie so oft durchlaufen haben.
Hier sagen wir also 4, wir haben int ohne Vorzeichen, müssen nicht ohne Vorzeichen sein,
da int I gleich 1 ist. Wir initialisieren die Regelungsvariable.
Und dann sagen wir, wenn ich weniger als zu zählen bin, werden wir beenden
und dann das Schleifenmaterial plus plus I modifizieren.
Das wird also laufen. Wieder die
1 bis jedoch die vom Benutzer eingegebene Nummer, 10 oder 20.
Und alles, was wir tun werden, ist zu sagen, dass Summe gleich Summe plus 1 ist.
Jetzt ist die for-Schleife so leistungsfähig, weil Sie mit der for-Schleife
viele Variablen ändern können.
Wir müssen nicht einmal diese Summe plus gleich I in den Körper der for-Schleife setzen.
Wir können es am Ende der letzten Aussage setzen.
Zusätzlich zur Erhöhung von I um 1 können wir also einfach Summe plus gleich I plus plus sagen.
Wir haben also alles in einer einzigen Codezeile
erledigt, und das zeigt Ihnen die Flexibilität. Das liegt alles daran, dass wir
die Variable in der for-Anweisung selbst ändern können. Wir müssen diese Körperlinie nicht haben.
Schauen wir uns dieses Beispiel in Codeblöcken an, um zu zeigen,
wie Sie es bearbeiten können, und um zu sehen, wie die Ausgabe aussieht.
Hier ist unser Beispiel, das wir in der Vorlesung hatten. Ich möchte weitermachen und versuchen, dies zu kompilieren.
Und wenn ich das kompiliere, werden Sie feststellen, dass ich einen Fehler habe.
Es heißt, ich kann meine Variable in meiner for-Anweisung nicht deklarieren. Dies liegt daran, dass ich eine ältere
Version des c-Compilers verwende. Ich verwende den C89.
Sie werden das wahrscheinlich nicht haben.
Aber um zu lösen, wenn Sie jemals diese Art von Fehler sehen, müssen
Sie ihn nur außerhalb der for-Schleife deklarieren. Also sagst du einfach unsigniert I.
Und dann initialisieren Sie es in
der for-Schleife, so ähnlich. Versuchen wir nun zu
bauen und ich muss nur einige dieser Formatspezifizierer loswerden.
Wenn ich also erfolgreich kompiliere und dieses
Programm ausführe, werden Sie sehen, wie die Schleife funktioniert.
Es wird mich bitten, die ganzen Zahlen einzugeben, die ich summieren möchte. Wenn ich 5 eingebe, summiert
es 1 2 3 4 und 5, was 15 ist.
Und was wir tun könnten, um dies zu debuggen, ist, dass wir der for-Schleife eine Klammer hinzufügen könnten,
und wir könnten nur sehen wollen, wie oft sie ausgeführt wird, wir könnten eine print-Anweisung
hinzufügen, um sie nicht unbedingt zu debuggen, sondern nur zu sehen, was los ist , könnten wir Inside Loop sagen.
Und dies wird uns sagen, dass die Schleife 5 Mal
läuft, weil ich laufen werde, um zu zählen.
Ich möchte also zeigen, wie oft dies ausgeführt wird. Wenn ich es jetzt
erstelle und ausführe, werde ich sehen, was bei jeder Iteration passiert.
Also werde ich 8 sagen.
Innerhalb der Schleife, innerhalb der Schleife, innerhalb der Schleife habe ich keinen Zeilenvorschub hinzugefügt. Es ist also schwer zu lesen,
aber die innere Schleife wird achtmal angezeigt.
Und dann fasse ich jede dieser Zahlen in Schleifen zusammen, sodass die Antwort 36,
1 plus 2 plus 3 plus 4 plus 5 plus 6 plus 7 plus 8 lautet.
Damit können Sie herumspielen. Aber auch hier
initialisieren wir unsere Regelungsvariable. Wir überprüfen den Zustand zum Beenden. Wir werden beenden, sobald wir die
Eingabe des Benutzers getroffen haben. Wenn der Benutzer 8 eingegeben hat,
werden wir 8 Mal ausgeführt und müssen dann I ändern. Wenn wir I hier nicht modifiziert hätten, hätten Sie eine Forever-Schleife.
Und was passieren würde, wenn Sie das Programm ausführen würden,
würde es für immer laufen.
Nachdem Sie die Nummer eingegeben haben, wird Ihr Programm also niemals beendet.
Sagen wir also, wir geben 6 ein, ich drücke die Eingabetaste, schau dir an, was
los ist, drucke einfach die Schleife hinein. Es ist nie aufregend.
Es ist eine Endlosschleife. Das Letzte ist also sehr, sehr wichtig. Sie möchten Ihre Regelungsvariable immer ändern.
Und wieder bestimmt die Regelungsvariable den Ausgang, in diesem Fall I.
Die for-Schleife wird also ziemlich oft verwendet.
Es ist sehr einfach zu bedienen und ermöglicht es Ihnen, 3 verschiedene Dinge innerhalb der Schleife zu tun.
Initialisieren Sie die Regelkreisvariable, überprüfen Sie
die Regelkreisregel der Variablen auf die Ausgangsbedingung und
ändern Sie diese Regelkreisvariable.
Das sind 3 Dinge, die Sie in einer Schleife tun müssen und die Sie in einer einzigen Anweisung tun können.
Lassen Sie mich jetzt ganz schnell über die Endlosschleife sprechen.
Also habe ich gerade eine Endlosschleife demonstriert. Hier verlassen Sie nie.
Und Sie sind nicht verpflichtet, Parameter in die for-Schleifenanweisung einzufügen.
Sie können tatsächlich absichtlich eine Endlosschleife schreiben.
Die Art und Weise, wie Sie das tun würden, ist, dass Sie einfach die Semikolons dort einfügen würden.
Sie hätten also eine for-Schleife mit 2 Semikolons.
Wenn Sie das jemals sehen, bedeutet dies, dass Sie eine Endlosschleife schreiben.
Normalerweise möchten Sie keine Endlosschleifen haben, aber
es gibt Zeiten, in denen die Bedingung für die Fortsetzung der Schleife fehlt.
Die Schleife wird auf unbestimmte Zeit fortgesetzt. Dies ist manchmal nützlich, wenn Sie Daten überwachen.
Wenn Sie also Daten überwachen, ist möglicherweise etwas drin.
Wenn Sie eine Forever-Schleife haben, haben Sie normalerweise auch einen
Ruhezustand, wodurch die Ausführung des Programms unterbrochen wird, möglicherweise für eine Sekunde, damit Sie etwas überwachen.
Der andere Anwendungsfall, in dem Sie möglicherweise eine Endlosschleife haben, ist, wenn Sie auf eine Verbindung warten.
Wenn Sie also warten und auf eine Verbindung warten oder etwas ziehen, um etwas
zu sehen, können Sie dies tun.
Nun argumentieren einige Leute, dass man niemals ziehen und niemals zuhören sollte,
aber das ist ein anderes Argument.
Dies ist wirklich der einzige Fall für einige für Endlosschleifen.
Vermeiden Sie Endlosschleifen so weit wie möglich, indem Sie diese Regelungsvariable ändern.
Ich hoffe das war hilfreich. Dies ist die for-Schleife.
Wir werden eine for-Schleife in einer unserer Herausforderungen verwenden, damit wir uns besser vertraut machen.
Danke.