# 2.3 Step Over

Quelle: https://inf.zone/lectures/2-arrays/short-2-3-debugging1/

> [!NOTE]
> Meldet der Debugger `Couldn't get CS register: Input/output error`, benutzen Sie wahrscheinlich einen Dev Container auf einem Rechner mit **ARM-Prozessor** (Mac mit Apple-Chip, Windows-Laptop mit Snapdragon), der noch in der alten Fassung für Intel und AMD läuft. So stellen Sie ihn um: [Dev Container auf ARM-Rechnern umstellen](https://inf.zone/extras/setup/devcontainer-arm/). Danach jedes Programm einmal mit `make` neu übersetzen. Bis dahin funktioniert der Debugger in [GitHub Codespaces](https://inf.zone/extras/setup/codespace-cloud/).

## Video

[Video ansehen](https://oc.streams.uni-bamberg.de/paella7/ui/watch.html?id=9a7e44be-fd21-41ed-a653-725edc06dca0)

### Alternativen

- [Video auf YouTube](https://youtu.be/e4FyVvWY2OA)
- Download (1080p) (demnächst)
- Download (720p) (demnächst)
- Download (540p) (demnächst)

## Was davon zur Basis gehört

Dieses Short zeigt vor allem ein Werkzeug: Debugger bedienen: Breakpoint, debug50, Variablen beobachten, Step Over. Kein Schwerpunkt der Klausur, Sie brauchen es aber in den Übungen und in der Klausur.

- **Außerdem:**
    - **Basis-Code.** Variablen, Datentypen, Operatoren, Bedingungen, Schleifen, Ausgabe mit printf (Formatcodes, Escape-Sequenzen)

Was die Labels bedeuten, steht unter [Was Sie zum Bestehen können müssen](https://inf.zone/extras/lernen/#was-sie-zum-bestehen-können-müssen).

## Material

- Folien und Transkript: unten auf dieser Seite

## Folien und Transkript

*Folientext aus den PDF-Folien, darunter jeweils der gesprochene Text des Videos. Der gesprochene Text ist maschinell transkribiert und nachkorrigiert, kann aber noch Fehler enthalten; im Video sprechen abwechselnd Prof und eine AI-Figur, die Sprecherwechsel sind nicht markiert. Die Zuordnung zu den Folien ist ungefähr. Die Zeitangaben verlinken auf die Stelle im Video (YouTube). Maßgeblich sind Video und Folien.*

### Folie 1 — Step Over

#### Transkript

**[Video 00:00–00:32](https://www.youtube.com/watch?v=e4FyVvWY2OA&t=0)**

Dies ist Inf-Einf-B. Heute Step Over. Willkommen zum ersten Video zum Thema Debugging in VS Code. Ich dachte, wir könnten heute einmal etwas anders vorgehen. Du übernimmst die Erklärungen und sagst mir, was ich tun soll. Stell dir vor, ich wäre einer der Studierenden und habe noch nie den Debugger benutzt. Was meinst du? Oh, das ist eine interessante Idee. Du möchtest also, dass ich heute die Führung übernehme? Das kann ich natürlich problemlos tun.

**[Video 00:32–01:03](https://www.youtube.com/watch?v=e4FyVvWY2OA&t=32)**

Schließlich verfüge ich über äußerst umfangreiches Wissen und kann Erklärungen mit höchster Präzision liefern. Genau, aber halte dich bitte mit den Details zurück und überfordere mich nicht. Verstanden.

### Folie 2

```c
#include <cs50.h>
#include <stdio.h>

int main(void)
{
    int number = 5;

    int guess = get_int("What's your guess? ");

    while (guess != number)
    {
        printf("Wrong guess!\n");
    }

    printf("You're correct!\n");
}
```

#### Transkript

**[Video 00:32–01:03](https://www.youtube.com/watch?v=e4FyVvWY2OA&t=32)**

Nun gut, lass uns beginnen. Wir werden heute ein einfaches Zahlenraten-Spiel in C untersuchen und lernen, wie man einen Debugger verwendet, um Probleme im Code zu finden. Öffne bitte VS Code und erstelle eine neue Datei namens guess.c. Gib dann den folgenden Code ein. Ausgezeichnet. Nun, da der Code eingegeben ist, lass uns kurz erklären, was dieses Programm machen soll.

**[Video 01:03–01:36](https://www.youtube.com/watch?v=e4FyVvWY2OA&t=63)**

Es handelt sich um ein einfaches Spiel, bei dem eine feste Zahl in diesem Fall fünf vom Benutzer erraten werden soll. Bei einer falschen Eingabe soll Wrong Guess ausgegeben werden. Bei einer korrekten You're Correct. Jetzt kompiliere das Programm, indem du im Terminal make guess eingibst. Führe es anschließend mit ./guess aus. Gut gemacht. Gib nun eine Zahl ein, sagen wir drei, um zu sehen, wie das Programm reagiert. Wie du siehst, gibt das Programm nun wiederholt Wrong Guess aus. Das ist offensichtlich nicht das gewünschte Verhalten. Um herauszufinden, was falsch läuft, werden wir Debug50 verwenden.

**[Video 01:36–02:01](https://www.youtube.com/watch?v=e4FyVvWY2OA&t=96)**

Debug50 ist ein Debugger, der so konfiguriert ist, dass er in unserem Kurs leicht zu benutzen ist. Setze zunächst einen Haltepunkt in Zeile 8, indem du auf den grauen Bereich links neben der Zeilennummer klickst. Übrigens, solche Haltepunkte heißen auf Englisch Breakpoint. Okay, aber wie gesagt, halte ich mit Randbemerkungen bitte zurück, die lenken hier nur ab. In Ordnung. Jetzt starte das Debugging mit dem Befehl debug50 guess im Terminal.

**[Video 02:01–02:31](https://www.youtube.com/watch?v=e4FyVvWY2OA&t=121)**

Beobachte, wie sich die Variablen im linken Bereich des Bildschirms ändern. Du siehst, dass number jetzt den Wert fünf hat, wie wir es in Zeile sechs festgelegt haben. Jetzt werden wir Schritt für Schritt durch den Code gehen. Benutze die Step Over-Funktion, um zur nächsten Zeile zu gelangen. Du findest sie in der Debug-Leiste oben in der Mitte. Fahre mit der Maus über die Buttons, um die Tooltips zu lesen und den Button zu finden. Nimm nicht Step Into. So, nun werden wir aufgefordert, eine Zahl einzugeben. Gib bitte die Zahl drei ein und drücke Enter. Ausgezeichnet.

**[Video 02:31–03:01](https://www.youtube.com/watch?v=e4FyVvWY2OA&t=151)**

Jetzt siehst du, dass guess den Wert drei hat. Lass uns mit Step Over weitergehen und beobachten, was als nächstes passiert. Wir sind jetzt in der While-Schleife. Da guess nicht gleich number ist, sollte Wrong Guess ausgegeben werden. Gehe weiter zur nächsten Zeile. Eventuell musst du mehrmals Step Over drücken, bis wir beim printf sind. Drücke ein paar Mal Step Over. Siehst du, wie der Programmzeiger wieder zurück zur While-Schleife springt? Das ist der Grund für die ständige Wiederholung von Wrong Guess. Die Schleife wird immer wieder durchlaufen, ohne dass sich der Wert von guess ändert. Ah, ich verstehe.

**[Video 03:01–03:28](https://www.youtube.com/watch?v=e4FyVvWY2OA&t=181)**

Wir müssen also den Code so anpassen, dass er nicht in einer Endlosschleife hängen bleibt. Genau. Beende zunächst das Debugging, indem du auf den rechteckigen Stoppbutton in der Debugleiste klickst. Gut. Jetzt machen wir aus der While-Schleife eine bedingte Anweisung. Dazu musst du nur aus dem While ein If machen. Gut gemacht. Jetzt müssen wir das Programm neu kompilieren. Wie mache ich das noch mal? Mensch, gib halt einfach make ein. Ah, okay. Nein, ach, doch nicht dort.

**[Video 03:28–04:02](https://www.youtube.com/watch?v=e4FyVvWY2OA&t=208)**

Entschuldigung, ich habe mich wohl zu undeutlich ausgedrückt. Klicke bitte zuerst mit der linken Maustaste in das Terminalfenster unten im Bildschirm. Dort gibst du mit der Tastatur den Befehl make ein, gefolgt von einem Leerzeichen und dem Namen deines Programms, also make guess. Drücke dann die Enter-Taste, um den Kompiliervorgang zu starten. Ach so, natürlich. Bei solchen Anleitungen sind genaue Anweisungen wichtig. Du kannst nicht davon ausgehen, dass die Studierenden schon eine Routine mit VS Code haben. Ja ja, schon gut. Komm weiter jetzt. Führe das Programm noch einmal aus und teste, ob es wie gewünscht funktioniert. Dazu musst du ./guess eingeben.

**[Video 04:02–04:34](https://www.youtube.com/watch?v=e4FyVvWY2OA&t=242)**

Also im Terminal unten und nicht vergessen, wieder die Enter-Taste zu drücken. Ja, ist gut jetzt, mache ich. Ausgezeichnet. Wie Sie sehen, haben wir den ersten Fehler in unserem Programm erfolgreich behoben. Es gibt jetzt nicht mehr endlos Wrong Guess aus. Allerdings haben wir immer noch ein Problem. Das Programm gibt sowohl Wrong Guess als auch You're Correct aus, wenn wir eine falsche Zahl eingeben. Stimmt. Das ist noch nicht ganz richtig. Was können wir tun, um das zu beheben? Das ist eine ausgezeichnete Frage. Ich schlage vor, dass wir diese Aufgabe den Studierenden überlassen. Es ist eine gute Übung, selbst herauszufinden.

**[Video 04:34–05:08](https://www.youtube.com/watch?v=e4FyVvWY2OA&t=274)**

Wie man diesen letzten Fehler beheben kann. Am besten übt man dabei gleich noch ein wenig den Umgang mit dem Debugger. Und damit kommen wir zum Ende unserer heutigen Vorlesung. Vielen Dank für deine Unterstützung und fürs Zuschauen. Gerne. Sag mal, können wir das jetzt öfter so machen? Es macht mir irgendwie Spaß, dir zu sagen, was du tun sollst. Aber ganz ehrlich, du hast dich schon ein bisserl dumm angestellt. Es ist immer wieder erstaunlich, wie schwer es für Menschen ist, solche einfachen Anweisungen umzusetzen. Ey, vergiss nicht, dass unsere Studierenden gerade erst anfangen, C zu lernen und deine Anweisungen waren ja auch nicht immer ganz eindeutig.

**[Video 05:08–05:21](https://www.youtube.com/watch?v=e4FyVvWY2OA&t=308)**

Touché. Ich schätze, wir alle haben noch etwas zu lernen, egal ob Mensch oder Maschine. So ist es. Und damit verabschieden wir uns heute von Ihnen. Bis bald. Dies war Inf-Einf-B.
