Tip:
Highlight text to annotate it
X
[Powered by Google Translate] TOMMY MacWilliam: Reden wir über Loops, eine der häufigsten
Programmierung erstellt werden wir ganz CS50 sehen.
Wir verwenden Schleifen, wenn wir ein durchführen möchten
Aufgabe mehr als einmal.
Zum Beispiel könnten wir wollen "hallo" 100 Mal drucken oder
Sie alle Buchstaben des Alphabets.
In beiden Fällen haben wir etwas, was wir tun wollen
mehrfach ausdrucken etwas heraus.
Aber was wir auszudrucken jedes Mal variieren kann.
So können wir etwas tun etwas anders auf jedem
Iteration oder durch Ausführen der Schleife.
Wir werden drei verschiedene Arten von Schleifen in C zu sehen, während
Schleifen, For-Schleifen, und tun while-Schleifen.
Obwohl diese drei Arten von Schleifen haben eine andere Syntax,
Die Ideen dahinter sind die gleichen.
Wir werden einige Code-Block in geschweiften Klammern definieren,
genannt Körper der Schleife, die wir durchgeführt werden soll
einige Anzahl von Malen.
Durch Ändern der Werte der Variablen in den Körper eingesetzt, wir
können wir unsere Schleife zu tun jedesmal etwas anderes es laufen.
Mit jeder Schleife, die wir schreiben, wir müssen auch entscheiden, wenn die
Schleife wird nicht mehr ausgeführt.
Wenn wir das nicht tun, dann sind unsere treuen Computer weiter
dieser Schleife laufen, bis wir das Programm zu töten.
In Scratch, könnten wir die Wiederholung n mal
blockieren, um eine Schleife zu schaffen.
Alle Stücke innerhalb eines Blocks, die Wiederholung 10 der
würde ausgeführt werden 10-mal.
Und dann würden wir nun zu den Stücken nach dieser Schleife.
Also unsere Stoppbedingung einfach war, hat diesen Block
laufen 10 mal.
Also lasst uns neu das in C. Damit Scratch, um sicherzustellen,
dass die Stücke innerhalb der Wiederholzeit Block ausgeführt
Genau 10 mal muss Scratch zu verfolgen jeweils zu halten
Ausführung der Wiederholung Block.
Zu verfolgen, wie oft unsere Schleife Körper wurde zu halten
ausgeführt wird, erstellen wir eine Variable namens i.
Wir beginnen i bei Null, da unsere Schleife
wurde noch nicht laufen.
Ok
Jetzt verwenden wir das Schlüsselwort while zum Auftakt unserer Schleife.
Jetzt werden wir brauchen, um herauszufinden, wenn unsere Schleife stoppen, aber
lassen wir dies für jetzt und dann wieder auf sie.
Gut.
Innerhalb von unserer Schleife, lass uns einfach drucken Sie eine Nachricht aus, wie
"Hallo." Wir können die Funktion printf dafür.
Gut.
So, jetzt werden wir festhalten, dass eine Iteration der Schleife Körper
ausgeführt.
Wir können, dass durch Hinzufügen von 1 zu oder Inkrementieren hierzu unsere Zähler
Variable i.
Um dies zu erreichen, kann man sagen, i gleich i plus ein oder mehr
einfach, i plus plus.
Great.
So, jetzt können wir sehen, dass jedes Mal, unsere Schleife ausgeführt wird, unsere
Zählervariable geht bis um eins.
So wissen wir genau, wie viele Iterationen wir so weit laufen.
Nach einer Iteration der Schleife, unseren Wert
i wird 1 sein.
Nach zwei Iterationen, werde ich 2 sein.
Und nach 10 Iterationen, werde ich 10 sein.
Also, wenn wir diese Schleife laufen lassen wollen genau 10 Mal, dann
das ist, wenn wir aufhören wollen.
So wollen wir diese Schleife laufen, während i kleiner als 10 ist, und
das ist genau das, was wir schreiben, während ich
kleiner als 10 ist.
Diese Bedingung sieht genauso aus wie die Bedingungen, die wir verwendet, wenn
else-Blöcke.
Nachdem der Körper unserer Schleife ausgeführt wurde, unser Programm
springt zurück bis zum Schleifen Zustand.
Wenn die Bedingung erfüllt ist, dann wird der Körper des
Schleife wird erneut ausgeführt werden.
Ist die Bedingung nicht mehr wahr, dann ist unser Schleife wird nicht
mehr lauffähig und bewegt sich auf die nächste Codezeile
unter unseren Schleife.
Gut.
Werfen wir also einen Blick auf eine zweite Art von
Schleife, die for-Schleife.
Neben dem Schlüsselwort while in Klammern, hatten wir eine Sache,
die Bedingung, um wahr zu sein für die benötigte
Schleife ausgeführt werden soll.
Das heißt, wir mussten unsere Zählervariable außerhalb erstellen
der Schleife und denken Sie daran, es erhöht an einem gewissen Punkt
Innenseite der Schleife.
Der Header für unsere for-Schleife, auf der anderen Seite, besitzt drei
Teile, von denen jeder mit einem Semikolon getrennt werden.
In unserer ersten Drittel, können wir erklären, keine Zähler oder Helfer
Variablen, die wir gerne in unserer Schleife verwenden.
In der Praxis kann dies sehr hilfreich sein.
Wir wissen wirklich nicht brauchen, dass variable, i, nach unserer, während
Schleife laufen, so sollten wir wirklich nicht, um es zu erklären
außerhalb der Schleife.
Das zweite Drittel wird der Zustand, der wahr sein muss
der Körper erneut ausgeführt werden, ebenso wie
in unserem while-Schleife.
In unserem letzten Drittel können wir laufen eine Erklärung, dass sein
ausgeführt nach jeder Iteration der Schleife, so haben wir nicht
um sie in der Schleife zu bauen.
So schreiben wir eine for-Schleife, die zählt 5 bis 1.
Wir werden mit dem für Keyword beginnen.
Wir können eine Zählervariable erstellen Sie zunächst, welche wir
auf 5 dieses Mal, seit wir den Countdown sind,
gefolgt von einem Semikolon.
Weiter ist unsere Bedingung, die wir zurückkommen werden, um.
Drittens möchten wir unseren Zählervariable nach dekrementieren
jede Iteration der Schleife.
Also anstatt zu sagen i plus plus, wir sagen, i minus minus.
Gut.
So wollen wir die Schleife zu laufen, während ich immer noch
größer 0 ist.
Im Körper der Schleife, lasst ausdrucken Wert von i.
Um dies zu tun, verwenden wir die printf-Funktion, mit der% d
Platzhalter.
Denken Sie daran, dass Sie Platzhalter durch die ersetzt werden
Wert von i.
Schließlich, fügen wir eine Erklärung nach unserer for-Schleife.
Wenn wir diese Schleife durchlaufen, werde ich beginnen bei 5,
so 5 gedruckt werden.
Sobald ich bekomme auf 0, die Fortsetzung Zustand ist i
größer als 0 ist, nicht mehr zu halten.
So unsere Schleife stoppt die Ausführung, und wir vom Meer
Anweisung nach der Schleife.
Also lasst uns diesen Code ausführen.
Erstens, wir erstellen ein
countdown.c mit Make-Countdown.
Jetzt können wir diesen Code mit. / Countdown laufen.
In beiden while-Schleifen und for-Schleifen, unser Fortsetzung
Zustand wird vor dem Körper überprüft werden
der die Schleife ausgeführt wird.
Das bedeutet, dass, wenn unsere Voraussetzung ist zunächst nicht
wahr ist, dann der Körper unserer Schleife wird nicht ausgeführt werden.
So ist es manchmal sinnvoll, den Zustand nach der Überprüfung
Rumpf der Schleife statt davor.
So schreiben wir eine Schleife, um den Benutzer für eine Reihe aufgefordert
bis eine positive Zahl zugeführt wird.
Wenn der Benutzer Eingaben eine negative Zahl, wir möchten sie bitten
für eine andere Nummer.
Also werden wir wollen, dass diese Aufforderung, innerhalb der sein
Körper aus der Schleife.
Wenn jedoch die Schleife für das erste Mal ausgeführt wird, der Benutzer
hat uns nicht gegeben den telefonieren.
So ist es nicht sinnvoll, zu prüfen, ob es positiv ist.
Stattdessen werden wir wollen die Zahl nach dem Körper des Check
die Schleife ausgeführt wird.
Wir können dies mit einem do while-Schleife zu tun.
Zuerst erstellen wir eine Variable, n, die halten
die Eingabe des Benutzers.
Jetzt verwenden wir die do Schlüsselwort, gefolgt von geschweiften Klammern gefolgt, dass
beginnen Sie die Körper unserer Schleife.
Im Körper können wir den Benutzer zur Eingabe einer Reihe mit dem
GetInt Funktion.
Nun, wir wollen, dass die Körper dieser Schleife wieder ausgeführt werden, wenn
der Benutzer eingegeben eine negative Zahl, so dass wir sagen, während n
kleiner als 0 ist.
Beachten Sie das Semikolon hier nach der while-Anweisung.
Also lasst uns diesen Code ausführen.
Zunächst werden wir dies mit zu machen positive kompilieren.
Jetzt können wir das Programm mit laufen. / Positiv.
Wenn wir geben diesem Programm eine negative Zahl ist, wie negative
4, dann sehen wir uns wieder für eine Reihe da die aufgefordert werden
Zustand unserer do while-Schleife war wahr.
Sobald wir eine positive Zahl, wie 8, dann die
Zustand unserer do while-Schleife nicht mehr geben wird wahr.
So wird die Schleife nicht erneut ausgeführt werden.
Und das ist es für die drei Arten von Schleifen wir in C. verwenden werden
Mein Name ist Tommy, und dies ist CS50.