[? DAN ARMADARAS:?] Hallo, Ich bin [? Dan Armadaras?].
Heute sind wir zu gehen sein Blick auf das Debugging.
Nicht nur werden wir sprechen über einige Techniken,
sondern auch wir gehen, zu betrachten einige der Merkmale enthalten
innerhalb des CS50 IDE, mit denen Sie einfach ein Programm zu debuggen.
>> Nur ein Beispiel, etwas, was schief gehen kann,
und es ist tatsächlich etwas, dass wir bereits gesehen.
In diesem Fall ist dies ein C-Programm daß nimmt eine ganze Zahl von dem Benutzer,
teilt es durch zwei und liefert die Ausgabe an den Benutzer zurück.
Nun, was wir gesehen haben, früher in Vorträgen,
wir wissen, dass dies tatsächlich dazu führen, bestimmte Arten von Divisionsaufgaben
wenn wir ungeraden Zahlen.
>> Genauer gesagt, werden wir einfach wegwerfen alles nach dem Komma.
Nun, wir wissen, dass dies zufällig der Fall sein.
Und wenn wir es laufen, können wir bestätigen, unseren Verdacht, erstens, durch die Zusammenstellung.
Und dann, durch Ausführen und Eingabe eine ungerade Anzahl.
>> Das ist nichts Neues.
Aber dies ist eigentlich eine Beispiel für einen Fehler, der
kann innerhalb eines größeren Programms vorhanden dass wird härter auf die Spur.
Auch wenn wir wissen, was das Problem ist der wahre Kern der Sache
Möglicherweise versuchen Sie, zu identifizieren Insbesondere an der der Fehler auftritt,
herauszufinden, was das Problem ist, und dann die Festsetzung es.
So bieten dies als Beispiel von dem, was könnte etwas sein,
dass wir bereits wissen, kann aber begraben werden in anderen Elementen des Codes.
>> So Öffnen dieser anderen Quelle Code-Datei als ein Beispiel,
diese Teilung Problem ist nun, Teil eines größeren Programms.
Dennoch könnte ein wenig sein bit erfunden, und wir
vielleicht in der Lage zu sein, leicht zu identifizieren, vor allem
da wir gerade über diese.
Aber wir herausfinden können, dass dies Problem kann in einem größeren Maßstab existieren.
>> Wenn ich diese kompilieren und jetzt führen Sie es, geben Sie eine ungerade Zahl ist,
können wir sehen, dass wir nicht genau erhalten die Ausgabe, die wir erwartet haben können.
In diesem besonderen Fall, könnten wir sagen, dass wir
wollen alle Zahlen zu zählen von einem bis zu einigen spezifischen Nummer.
Und wir können sehen, dass wir haben eine Reihe von Problemen
hier, wenn wir die Ausgabe, einfach, 0 und 1, wenn wir eine Eingabe von 5.
>> So dass wir wissen bereits, dass es gibt ein Problem hier.
Aber wir können nicht genau wissen, wo dieses Problem tatsächlich existiert.
Jetzt ist einer der Wege, wir können versuchen, dieses Problem zu beheben
ist etwas, was wir haben bereits eingeführt worden.
Wir können es einfach verwenden, in einem größeren Maßstab.
>> In Zeile 14 haben wir Diese Funktion printf,
, die uns aus dem Stand drucken können der verschiedenen Informationen.
Und das ist etwas, dass Sie sollte in Ihrem Programm nutzen
um zu versuchen, herauszufinden, was genau ist geschieht in verschiedenen Zeilen Code.
Selbst wenn dies nicht der endgültige Ausgabe, dass wir tatsächlich
will aus produzieren Dieses Programm, das wir immer noch
könnte einige Debug haben Aussagen, wo wir
kann versuchen, herauszufinden, genau das, was innerhalb unseres Codes geschieht.
>> Also in diesem Fall, ich will printf mit dem Debug-Tag.
In diesem Fall ist dies nur eine Debug-String
dass ich bis abstoßend, so dass es sehr klar in der Ausgabe von meinem Code
was es ist, dass ich will, um zu zeigen.
Und Ausgangs hier die Anzahl dass wir berechnet.
>> In diesem Fall, könnte ich wollen genau wissen,
was passiert, und vor nach einiger spezifischer Berechnung.
So könnte ich eine printf, bevor verwenden und nach dieser Codezeile.
In diesem Fall könnte ich auch machen es ein bisschen mehr klar,
mit den Worten: debug vor und Debug nach so
dass ich mich nicht mit verwirren mehrere Zeilen, die identisch aussehen.
>> Wenn wir nun diese neu kompilieren und ausführen es, geben Sie eine Zahl wie fünf wieder,
können wir sehen, dass wir jetzt vor und nach dem Ausgang
und finden Sie, dass wir nicht einen klaren getan Division oder klar mit der Anzahl
dass wir tatsächlich tun will.
Nun in diesem Fall ist dies nicht wirklich eine klare Ausgangs.
Es ist nicht wirklich ein klares Ergebnis, Wir wollen aus diesem Programm.
>> Und dies ist wiederum ein wenig gekünstelt.
Aber vielleicht, eines der Dinge, die wir tun könnten, wenn die Spezifikation, sagte
dass wir, dies durch unterteilen wollen 2 und fügen Sie 1-- so mit anderen Worten,
wir dann runden up-- möchten könnten wir, dass wir wissen,
zu tun, dass bestimmte Sache, in diesem Fall.
Jetzt ist hier wissen wir, dass wir in der in der Lage, ein, um unsere halbiert Nummer hinzuzufügen.
>> Lassen Sie uns diese neu kompilieren und bestätigen, dass dies
verhält sich die Art und Weise, die wir wollen.
Das können wir jetzt, bevor zu sehen mit, haben wir die Zahl 5.
Nachdem haben wir die Nummer 3, die nach unserer Spezifikation
ist das, was wir tun wollten.
Aber wenn wir uns die hier ausgegeben, können wir
zu sehen, dass wir vielleicht ein anderes haben bug haupt, das ist
dass wir beginnen unsere Zählung von 0.
>> Jetzt wieder, das ist etwas, dass wir in der Vergangenheit gesehen haben
und wir relativ leicht beheben kann.
Aber in diesem Fall haben wir hatte auch den Vorteil,
der Verwendung der Anweisung printf direkt in der for-Schleife
genau zu wissen, wo dass Fehler auftreten.
So printf Aussagen dabei hilfreich,
Sie bestimmen, wo, Gerade im Quellcode,
ein spezifischer Fehler auftritt.
>> Und es ist auch wichtig zu erkennen, dass, wie wir das Schreiben von Code,
könnten wir Annahmen über den Zustand eines Programms.
Oder wir könnten Annahmen zu welchem ​​Teil des Programms
ist eigentlich richtig oder falsch, wenn Später, als wir an diesem Programm zu erstellen
und machen es Teil einer komplexe und größere Programm
, dass wir erkennen, dass einige Aspekte der, dass ist eigentlich Buggy.
>> Mit printf kann wirklich helfen, eingrenzen und identifizieren
die Regionen ein Programm, das nicht kann werden genau die Art und Weise verhalten, dass wir
erwartet, basierend auf unseren Annahmen.
Aber es gibt andere Werkzeuge zur Verfügung, ebenso,
dass es uns ermöglichen, um Abbildung zu versuchen aus dem ein Fehler auftritt,
und auch, insbesondere, was die Dinge innerhalb des Programms geschieht.
>> Also mit printf ist sehr sinnvoll, wenn wir wollen,
um bestimmte Bereiche zu identifizieren ein Programm, das einige Fehler haben.
Sondern es wird auch mühsame nach einer Weile.
In diesem Fall ist dies ein relativ einfaches Programm
mit nur einer oder zwei Variablen.
Und es wird für uns sehr einfach, drucken Sie den Wert dieser Variablen
in Zusammenhang mit der größeren Programms.
>> Aber wir einen anderen haben könnte Programm, das viele Variablen hat.
Und es kann nicht ganz sein so einfach zu verwenden printf
um zu versuchen, zu bewerten, was geschieht, zu jedem von diesen Variablen
als das Programm ausgeführt wird.
Es gibt ein Programm, das vorhanden ist rief ein Debugger-Programm.
In diesem Fall ist der, dass wir Verwendung der GNU-Debugger oder GDB,
dass erlaubt uns, die internen inspizieren Funktionsweise des Programms in einer wesentlich
detailliert.
>> Wir können tatsächlich ausführen GDB über die Befehlszeile
hier, indem Sie einfach GDB und der Befehl, die wir debuggen möchten.
In diesem Fall zählen.
Nun in diesem Fall können wir sehen, dass es bringt uns zu einer Eingabeaufforderung, die GDB sagt.
Und wir können tatsächlich Befehle ausführen, um GDB
um die Ausführung der tatsächlichen Beginn Programm, hör auf zu bestimmten Zeitpunkten,
die Variablen zu bewerten und überprüfen Sie die Variablen,
gibt es in der Programmzustand in diesem Moment,
und so weiter und so fort.
Sie bietet eine Menge Power, mit uns.
>> Aber es passiert einfach so, dass der CS50 IDE auch
bietet eine grafische Oberfläche oder ein Benutzer Schnittstelle für GDB, dass
ermöglicht es uns, dies zu tun, ohne dass Die Befehlszeilenschnittstelle auch immer
oder überhaupt noch.
Die Möglichkeit, dass ich zugreifen, dass ist die Verwendung des Debug-Taste
an der Spitze des CS50 IDE.
Jetzt in der Vergangenheit, was wir haben, zu sehen ist, dass wir den Befehl
Linie zu kompilieren und dann ein Programm ausführen.
>> Die Debug-Taste funktioniert beide dieser Schritte.
Aber es auch öffnet die Debugger-Register auf der rechten
dass ermöglicht es uns, eine Vielzahl inspizieren der Eigenschaften des Programms
wie es ausgeführt wird.
Wenn ich auf Debuggen, in diesem Fall wird es bringen
ein neuer Tab in der Konsole Fenster ganz unten.
>> Und Sie können sehen, dass diese Lasche einige Informationen an der Spitze.
Und wir können weitgehend ignorieren.
Aber eines der Dinge, dass wir zu bemerken wollen
ist, dass es ausgibt die gleiche Sache, dass wir
wäre, wenn wir versuchten, make auf das C-Programm im Terminal-Fenster.
>> Hier können wir sehen, es läuft Klang, und es hat eine Vielzahl von Flags,
und es wird der Zusammenstellung unserer count.c-Datei, denen die ausgewählten Registerkarte zu der Zeit war
dass ich auf Debug.
Also das ist sehr nützlich, weil Jetzt mit diesen Debug-Taste,
wir können gleichzeitig zu kompilieren und dann das Programm ausführen, dass wir tatsächlich
will laufen.
>> Eine der Fahnen, die ist wichtig ist, in diesem Fall
wir haben eigentlich mit gewesen am längsten
aber auch nur tat etwas Hand winken [unverständlich], die
ist dies eine genau hier.
Im Klang, heißt es -ggdb3.
In diesem Fall ist das, was wir erzählt clang unsere Compiler,
ist, dass wir unser Programm kompilieren wollen.
Sondern auch, was sind genannt Symbolinformationen
so dass der Compiler tatsächlich Zugang zu einer Menge des zu Grunde liegenden Informationen
innerhalb des Programms enthalten ist.
>> Genauer gesagt, die Zahl Funktionen, die ich habe,
die Namen der Funktionen, die Variablen, die Typen
dass diese Variablen sind, und eine Vielzahl andere Dinge, die den Debugger helfen
führen seinen Betrieb.
Jetzt gibt es etwas anderes das ist wichtig zu erwähnen,
wenn wir diskutieren Lauf ein Programm auf diese Weise.
>> Beachten Sie, dass es tatsächlich eine neue Registerkarte in unserer Konsole gebracht
entlang der Unterseite.
Wir müssen nicht mehr zu interagieren direkt mit dem Terminal-Fenster.
Aber diese neue Registerkarte ist eigentlich ein Terminal-Fenster.
Es einfach ist spezifisch für die Lauf Programm, das wir geschaffen haben.
>> Feststellen, dass an der Unterseite, in Kombination mit einigen Ausgangs
von clang den Compiler und GDB, die wir größtenteils zu ignorieren,
andererseits weist sie den Ausgang des unser Programm ganz unten.
Jetzt ist es wichtig zu erkennen, dass dieses eine Fenster tatsächlich
zeigen Ihnen die von Ihrem Programmausgabe
kann aber auch Eingabe akzeptieren für dieses Programm, wie gut.
>> So Hinweis, der besagt Bitte geben Sie eine Zahl,
die die gleiche Ausgabe, die wir hatte im Terminalfenster vor.
Aber es ist jetzt in dieser neuen Registerkarte angezeigt.
Ich kann Eingang eine Nummer.
Und es wird tatsächlich Funktion als wir erwarten
zeigt uns unsere debug, Ausgang, die Ausgabe, die fehlerhaft sein könnte,
wie wir zuvor gesehen haben.
Und am unteren Ende, das tatsächlich hat einige zusätzliche Ausgangs
vom BIP nur sagen, dass dieses Programm beendet ist.
>> Nun, wie Sie in das sah insbesondere Durchlauf,
es war nicht besonders nützlich, weil auch
obwohl wir das Debugger-Menü zu kommen up, das war immer noch ein laufendes Programm.
Zu keinem Zeitpunkt habe es tatsächlich unterbrechen die Ausführung für uns
in der Lage sein, alle zu prüfen sein, die Variablen innerhalb enthalten.
Da ist noch etwas dass wir, um zu tun haben
um GDB erhalten, zu erkennen, dass wir wollen, zur Ausführung des Programms unterbrechen
und nicht nur lassen Sie es gehen normalerweise als würden wir in jedem anderen Fall.
>> Um die Ausführung zu unterbrechen, zu irgendeinem bestimmten Zeile,
wir brauchen, um zu schaffen, was ist genannt Bruchstelle.
Und eine Bruchstelle ist sehr einfach erstellt in diesem CS50 IDE, indem Sie mit der Maus
und klicken Sie direkt auf der linken Seite einiger spezifischer Zeilennummer.
Sobald ich das tun, ein roter Punkt angezeigt wird, die anzeigt,
dass diese Zeile ist jetzt ein Bruchstelle.
>> Und das nächste Mal, das ich laufen GDB, es wird die Ausführung an diesem Haltepunkt stoppen
wenn es, dass die Codezeile erreicht.
Nun ist dies ein wichtiger was zu realisieren
dass es nicht notwendigerweise der Fall, dass jede Zeile Code
ist eigentlich erreichbar.
Wenn ich, um eine Funktion zu erstellen hier, für nichtig example-- F--
und einfach eine Druckzeile hier-- hallo world-- wenn ich diese Funktion nicht aufrufen,
es wird der Fall sein, dass, wenn ich einen Haltepunkt hier,
die Funktion nie aufgerufen werden.
Und daher dieser insbesondere Bruchstelle
wird nie anhalten Ausführung des Programms.
>> Also lassen Sie uns sagen, dass ich mich richtig zu erstellen einen Haltepunkt auf einige Codezeile
dass auch tatsächlich durchgeführt werden.
Nun in diesem Fall ist dies die erste Zeile in der Hauptfunktion.
So wird es sicherlich der Fall sein, dass, sobald ich die Ausführung zu beginnen,
die erste Zeile zu erreichen.
GDB wird die Ausführung angehalten.
Und dann werde ich in der Lage, interagieren mit dem Debugger.
>> Sie können mehrere Linien als Set Breakpoints, wenn Sie möchten.
Wir können auch eine Zeile nach oben hier in diesem Codesegment
daß nie erreicht wird.
Und wir können auch weiter unten eingestellten.
Der Grund, dass wir Dies wollen wir tun
Gehen Sie in ein bisschen mehr Detail in nur einem Augenblick.
So jetzt, lassen Sie mich nur zu deaktivieren Diese zusätzlichen Haltepunkte
so dass wir, was passiert, schauen wenn ich ein einziges Break
Punkt in meinem Programm.
Ich habe einige Änderungen zu diesem Programm.
Also muss ich sie zu speichern.
Ich werde Debug klicken, so dass ich kann, beginnen die Zusammenstellung und dann
Ausführung des Debuggers.
>> Wir werden sehen, dass nach Augenblicken der Linie, die wir nach der Pause gewählt
Punkt wird gelb hervorgehoben.
Wir können auch feststellen, dass in der oben rechts in der Austestkonsole
dass das Symbol Pause gemacht hat in ein wenig Spiel-Symbol.
Das heißt, wir haben Pause Ausführung, in diesem speziellen Fall.
Und schlagen die Play-Taste würde es uns ermöglichen, die Ausführung wieder aufzunehmen
an diesem bestimmten Punkt.
>> Beachten Sie, dass es gibt ein paar andere Knopf in dieser Debug-Panel,
auch.
Überschritt, der mir erlaubt auszuführen, dass eine Zeile Code
und Schritt über zu dieser Linie, um die nächste, was in diesem Fall,
würde, dass der printf bedeuten Anweisung ausgeführt wird.
Und es wird dann Pause Ausführung in Zeile 13, wie so.
>> Und es gibt auch ein Schritt in-Funktion, die
ist nützlich, wenn ich anderen erstellt Funktionen anderer Stelle im Quellcode.
Und ich möchte in Schritt diese Funktionen statt
ausgeführt wird, die Funktion als Ganzes.
Aber wir werden in dem Schritt mehr sehen in-Funktion in nur einem Augenblick.
Jetzt bemerken einige andere Dinge, tatsächlich existieren innerhalb dieser Debug-Panel.
>> Wir haben diese Platte genannt Aufruf-Liste, die uns zeigt,
wo wir genau sind.
In diesem Fall wird im Inneren sind wir der Hauptfunktion.
Unser Skript aufgerufen count.c.
Und wir zufällig auf sein Zeile 13, Spalte eins, die
ist genau das, was die hervorgehobenen Bereich der Quellcode angibt, wie gut.
>> Nun beachtet, dass dies zeigt auch, unter dem lokalen variablem Querschnitt
alle Variablen, gibt es innerhalb dieser Funktion.
Es ist wichtig zu beachten, dass alle Variablen
wird in dieser lokalen Variablen angezeigt Abschnitt innerhalb einer Funktion,
noch bevor sie definiert sind.
Hier können wir sehen, dass wir eine Variable haben genannt num, hat einen Standardwert von 0,
und es ist vom Typ int.
>> Nun, bevor wir tatsächlich initialisieren alle diese Variablen,
wir sind nicht notwendigerweise garantiert, um einen Wert von 0 zu sehen.
Und in Abhängigkeit von anderen Hinrichtungen dass Sie durchgeführt haben
und der Zustand des Speichers, wenn Sie tatsächlich führen Sie dieses Programm,
Sie können, dass Sie finden, Sie Werte von 0 nicht sehen
und stattdessen einige andere verrückte Zahlen.
>> Aber keine Sorgen machen.
Es wird nicht relevant, bis sein Sie tatsächlich initialisiert den Wert.
Nun in diesem Fall können wir sehen Ich habe einige Ausgänge durchgeführt.
Und ich bin, gerade jetzt, pausiert die Ausführung.
Aber in diesem Fall, was Ich wirklich tun möchte,
ist es jetzt über diese Leitung Schritt der Code, so dass ich tatsächlich
Abfrage der Benutzer für die int, dass Wir wollen in unserem Programm verwenden.
>> Nun in diesem Fall, wenn Ich schlug Schritt über, Ankündigung
dass die Pause oder vielmehr die Wiederaufnahme- Button hat auf diese Schaltfläche Pause verändert
da dieser Code tatsächlich auszuführen.
Was ist los im Augenblick ist, dass es
auf uns wartet, um Eingangs einige Informationen wie wir von unseren Ausgangs Text sehen
ganz unten.
>> So jetzt ist dies eigentlich nicht angehalten,
obwohl es, irgendwie, scheint zu sein, weil nichts passiert.
Aber es passiert einfach so, dass in meinem speziellen Fall in Zeile 13,
Ich warte auf Benutzereingaben.
Usw. GDB ist nicht in der Lage zu kontrollieren ein Programm, wie es ausgeführt wird.
>> Jetzt ist das nächste Mal, dass ich an manchen input-- so werde ich diese Zahl 5 eingeben,
Wie wir in der gesehen haben past-- drücken Sie Return, und wir
Beachten Sie, dass sofort, GDB Pausen und wiederum unterstreicht die nächste Zeile.
Aber beachten Sie, dass jetzt, da ein Ergebnis unserer Eingabe eines Wertes,
haben wir diesen Wert innerhalb aktualisiert von unseren lokalen Variablen, die
ist sehr nützlich, um genau zu wissen, was diese Zahl war im Speicher.
>> Jetzt kann ich dieses Programm ermöglichen, auch weiterhin spielen, bis das Ende der Ausführung
indem Sie auf Fortsetzen.
Das können wir sehr schnell zu sehen wird das Programm die Ausführung Finish
bei gleicher Leistung, die wir hatte vor, der Debugger geschlossen,
und jetzt dieses Programm vollständig gestoppt.
>> Ich zeigen, dass nur für die Zwecken zu sehen, was
passiert, wenn wir tatsächlich getroffen Lebenslauf.
Aber wir tatsächlich sind los will wieder in dieses Programm gehen
so dass wir versuchen, zu debuggen genau, was geschieht.
Jetzt, wo ich mit dem Debugger, darf ich brauchen diese Debug printf-Anweisungen.
>> So konnte ich sie zu entfernen, wie ich werde tun, Jetzt, nur um wieder zurück zu unserer einfacheren Code zu gehen
dass wir vor einem Moment hatte.
Nun, wenn ich spare den programmieren und ausführen,
wird es, wieder in diesem Anfangs gehen brechen Punkt, dass ich auf der Linie 11 hatte.
Und ich werde in der Lage, zu prüfen sein, meine Variablen, wie ich will, um zu tun.
>> Es passiert einfach so, dass diese Teil ist nicht sehr interessant,
Und ich weiß, dass ich werde ausdrucken diese Aussage.
Bitte geben Sie eine Zahl ein.
Und dann weiß ich, dass ich werde um den Benutzer für die ganze Zahl fragen.
Also vielleicht, habe ich eigentlich verschieben möchten meine Haltepunkt ein wenig weiter nach unten.
>> Sie können Haltepunkte entfernen indem Sie wiederum direkt
links von dieser Zeilennummer an.
Das red dot verschwindet, wodurch angezeigt dass diese Bruchstelle ist jetzt weg.
Nun in diesem Fall Ausführung wurde angehalten.
Und so ist es nicht tatsächlich zu wieder in diesem besonderen Fall.
Aber ich kann eine Pause eingestellt Punkt ein wenig später.
>> Und wenn ich jetzt wieder meine Code, wird es wieder aufzunehmen und zu sagen
der Punkt dieser Bruchstelle.
Wieder schlug ich fortsetzen.
Mag nichts passiert zu sein scheinen.
Aber das ist, weil mein Code auf eine Eingabe wartet.
Ich werde eine Reihe 5 einzugeben, drücken Sie die Eingabetaste, und Jetzt der nächste Haltepunkt wird betroffen sein.
>> Nun in diesem Fall diese ist die Codezeile
dass vor, wir wussten, passiert fehlerhaft sein.
Lassen Sie uns also zu beurteilen, was passiert, an diesem bestimmten Punkt in der Zeit.
Wenn eine Linie markiert ist, diese Linie ist noch nicht ausgeführt worden ist.
Also in diesem Fall, können wir sehen, dass ich eine Nummer, die
Ich habe eine ganze Zahl genannt num die einen Wert 5 hat.
Und ich werde die Durchführung einige Mathematik auf diese Zahl.
>> Wenn ich Schritt auf, dass, we can feststellen, dass Sie den Wert für num
wurde in Übereinstimmung mit dem geänderten Arithmetik, die wir tatsächlich getan haben.
Und jetzt, wo wir sind dies für Schleife innerhalb
oder jetzt, dass die for-Schleife selbst markiert ist,
wir sehen, dass wir eine neue Variable i genannt, dass
wird sich in die for-Schleife verwendet werden.
>> Jetzt erinnere ich vor diesem erwähnt, dass manchmal sind Sie
gehen, um eine Art von verrückten sehen Zahlen als Standard vor dieser Nummer
oder die Variable tatsächlich initialisiert.
Das können wir genau sehen, hier in der diese Variable
rief ich, was nicht hat noch initialisiert
zum Zeitpunkt der Hervorhebung.
Aber wir können sehen, dass es eine gewisse Anzahl dass wir nicht wirklich erwartet.
>> Das ist ok.
Machen Sie sich keine Sorgen machen denn wir haben nicht wirklich
initialisiert die Zahl ist, bis ich Schritt über diese Leitung und dem Wert
i auf den Wert 1 initialisiert.
So zu sehen, dass das ist eigentlich der Fall ist, lassen Sie uns Schritt über.
Wir können jetzt sehen, dass diese Linie ausgeführt wurde.
Und wir sind jetzt Hervorheben Diese printf Linie.
>> Und wir können nun sehen, wie unsere Werte i und 3 wurden im Laufe der Zeit verändert.
Dies ist sehr nützlich zu machen, in der Tat, ist es, Linien wiederholt Schritt über.
Und Sie, was tatsächlich finden passiert im Inneren des for-Schleife
und was passiert mit der Variablen innerhalb der for-Schleife, dass
so dass die Programmausführung erfolgt ein Schritt zu einem Zeitpunkt.
>> An diesem Punkt, I stieg über gerade genug,
dass ich jetzt am Ende meines Programms.
Wenn ich Schritt auf, dass, wird es tatsächlich Ausführung aufhören
wie wir in der Vergangenheit gesehen haben.
Lassen Sie mich diese neu zu starten, noch einmal, so dass ich etwas anderes darauf hin,
auch.
>> In diesem Fall ist es Jetzt fragen mich, wieder,
für eine Zahl, die Ich werde wieder in Kraft.
Aber dieses Mal werde ich in geben eine größere Anzahl, so dass die for-Schleife
wird mehrmals durchlaufen.
In diesem Fall werde ich um einen Wert von 11 eingeben.
>> Jetzt wieder, weil ich eingestellt einen Haltepunkt in Zeile 15,
es geht um die Zeile zu markieren.
Wir können sehen, dass unsere Nummer 11 richtig ist
in unserem lokalen Variablen vertreten.
Stieg über das, können wir jetzt beobachten, was passiert, um unseren Wert von i
wie wir vorgehen Innere dieser for-Schleife.
Es wird erhöht, jedes Mal wenn wir erreichen die Spitze, dass for-Schleife.
>> Jetzt eines der Dinge, das könnte nützlich sein, um während der Ausführung zu tun
dieses Programms ist für mich eigentlich ändern Sie die Variablen Midstream zu sehen
Was passiert mit meinem Programm.
In diesem Fall kann ich eigentlich doppelklicken Sie auf den Wert.
Beachten Sie, dass es ein Textfeld.
>> Jetzt kann ich verschiedene eingeben Insgesamt schätzen
zu sehen, wie mein Programm verhält wenn ich diese Variable verändert.
Nun in diesem Fall die Variable i enthält nun den Wert 10.
Aber das Programm noch in der Ausführung angehalten.
Als ich Schritt über, sehe ich, dass die Wert i, die ich als 10 eingegeben,
nicht größer als der Wert von num, was bewirkt, dass unmittelbar die for-Schleife
zu stoppen Ausführen.
>> Nun, das ist nicht der einzige Grund, warum Sie würde
wollen die Variable an Stelle ändern.
Sie könnte in der Tat wollen zu versuchen, es so zu modifizieren
dass Sie fortfahren können Ausführung einer Schleife
oder so, dass Sie ändern können einen gewissen Wert, bevor es
eine bestimmte Gruppe von arithmetischen erreicht dass Sie sind dabei, das durchzuführen.
>> So, jetzt, dass wir tatsächlich verändern die Wert von i als das Programm ausgeführt wurde,
es verursacht die for-Schleife zu beenden vorzeitig wegen, ganz plötzlich, i
passiert größer als der Wert zu sein, von num, was bedeutet, dass die for-Schleife
nicht mehr durchgeführt werden musste.
Ferner kam es zu dem sein Fall, dass wir verändert den Wert von i
wenn die Leitung 17 wurde hervorgehoben, die der Zeitpunkt war,
dass die für die Schleifenausführung tatsächlich ausgewertet wird.
>> Wenn ich den Wert verändert i auf einer anderen Leitung, sagen, 19,
würden wir anders gesehen haben Verhalten, da die Leitung 19 würde
haben, bevor die Schleife ausgeführt wird Bedingung wurde neu bewertet.
Jetzt an diesem Punkt bin ich wieder, Am Ende des Programms.
Und ich kann zulassen, dass dies, um fortzufahren erlauben mein Programm auf natürliche Weise zu beenden.
Aber es gibt ein paar Dinge, die wichtig zum Mitnehmen sind
von diesem besonderen Diskussion.
Sie brauchen, um zu bewerten Ihre eigenen Annahmen
darüber, wie der Code sollte sein Verhalten.
Jedes Mal, wenn Sie denken, dass einige Stück der Code, den Sie wissen, kommt, um zu arbeiten,
das könnte eine rote Fahne zu gehen Rücken und zu bewerten, und sicher sein,
dass Ihre Annahme wie das Code-Betriebs
tatsächlich wahr ist, wie es ist im Quellcode zum Ausdruck gebracht.
>> Aber noch mehr, um Punkt war, wenn wir mit dem Debugger,
Sie können Haltepunkte setzen bei verschiedene Codezeilen,
welche den Debugger, um zu bewirken wird unterbrechen die Ausführung an jeder dieser Linien
so dass Sie die zu bewerten Speicher oder sogar ändern Sie sie fest.
Und wieder, denken Sie daran, dass Sie erstellen Sie mehrere Haltepunkte, so dass Sie
kann auch die Ausführung wieder aufzunehmen, überspringen über große Teile des Codes,
und es wird automatisch angehalten bei der nächsten Haltepunkt.
>> Es gibt tatsächlich fortgeschrittenere Features des Debuggers, wie gut.
Aber wir müssen Sie sich beziehen zu einigen nachfolgenden Videos
um wirklich zu necken auseinander, wie , jene besondere Funktionen zu nutzen.
Denn jetzt, danke Dank für das Aufpassen.
Und viel Glück Debugging.