Lektion 0: Entwicklungsumgebung

In dieser Übung zeigen wir, wie man eine Programmierumgebung in VSCode einrichtet. Außerdem zeigen wir, wie die IDE dir beim Kompilieren, Ausführen und Debuggen deines Codes unterstützen kann.

Diese Anleitung ist für alle gedacht, die noch keine fertige Programmierumgebung haben oder mit ihrer einfach nicht zufrieden sind und etwas Neues ausprobieren möchten. Fühle dich frei, etwas anderes zu tun, sei es eine andere IDE wie CLion oder einen einfachen Texteditor zu verwenden. Sei dir aber bewusst, dass wir dir dann vielleicht nicht so gut helfen können. Versuche auf jeden Fall sicherzustellen, dass du einen Debugger verwenden kannst.

VSCode und Extensions

Hole dir hier VSCode, falls du es noch nicht getan hast. Konkrete Schritte könnten von deinem Betriebssystem abhängen.

Falls du mit Windows arbeitest, wirst du dir vielleicht das Windows Subsystem für Linux (WSL) besorgen wollen, mit dem du eine Linux-Shell von Windows aus starten kannst.

Ich persönlich finde die Arbeit mit einer Unix-Shell viel angenehmer, und viele Open-Source-Projekte sind von vornherein für Linux entwickelt worden. Davon abgesehen, solltest du auch mit einer reinen Windows-Umgebung gut zurechtkommen. Die Entscheidung ist also allein dir überlassen.

VSCode hat keine eingebauten C-Tools. Mit der C/C++ Extension Pack-Erweiterung erhältst du alle Funktionen, die wir benötigen werden. Wähle hierfür an der linken Seite das Extensions Menü aus.

Code Schreiben

  1. Öffne einen leeren Ordern in VSCode
  2. Erstelle eine Datei und nenne sie hallo.c.
  3. Füge die folgenden Codezeilen ein:
#include <stdio.h>

int main(){
    printf("Hello World.\n");
}

Code kompilieren

Zu den Erweiterungen, die wir in den vorherigen Schritten installiert haben, gehört auch CMake. Wir werden die CMake-Tools von VSCode verwenden, um unsere Projekte zu kompilieren. Im Folgenden findest du eine kurze Zusammenfassung dessen, was CMake genau nutzt.

Wie du vielleicht schon weißt, ist eine Quellcodedatei dazu gedacht, für Menschen lesbar zu sein, nicht für Maschinen. Wenn wir versuchen würden, C-Code direkt als Programm auszuführen, wäre der Inhalt der Datei für die CPU nur ein Haufen Unsinn. C-Quellcode muss daher in ein anderes Programm, einen Compiler, eingespeist werden, dessen Aufgabe es ist, korrekten C-Code in Maschinencode zu übersetzen, d.h. zu kompilieren.

Der einfachste Weg, um diesen Code zu kompilieren, ist dieser Befehl (zumindest auf Linux):

gcc hello.c

Solange wir nur mit ein paar Dateien arbeiten und unser Projekt klein bleibt, ist dies eine völlig akzeptable Methode zum Kompilieren von Code. Die meisten Projekte sind jedoch komplexer als das. Es kann vorkommen, dass man eine große Anzahl von Quellcodedateien hat, von denen einige vielleicht für ganz verschiedene Zwecke wie Tests oder eine andere Plattform gedacht sind. Das korrekte Kompilieren kann schnell komplexer werden als das Schreiben des Codes selbst.

Für diesen Zweck gibt es das Werkzeug make. Dies ist weder der richtige Zeitpunkt, noch der richtige Ort, um eine ausführliche Diskussion über make zu führen. Im Wesentlichen stützt sich make auf Makefiles, das sind Dateien, in denen ein Entwickler beschreiben kann, welcher Compiler-Befehl ausgeführt werden muss, um den Code wie gewünscht zu kompilieren. Ironischerweise kann ein Makefile auch ziemlich komplex werden, und genau hier kommt CMake ins Spiel. CMake kann verwendet werden, um automatisch Makefiles zu erzeugen.

C-Compiler, Make und CMake sind allesamt ein ganz eigenes Metier. Indem man sich mit ihnen beschäftigt und sie versteht, kann man eigentlich nur ein besserer C-Entwickler werden. Für diese Woche ist jedoch geplant, CMake einzurichten, sodass wir unsere Projekte einfach per Knopfdruck in unserer IDE kompilieren können.

Lade dafür die Datei CMakeLists.txt herunter und füge sie deinem Projektordner hinzu. Diese Datei enthält das absolute Minimum, damit dein Projekt kompiliert werden kann. Wähle nun das GCC Toolkit indem du von VSCode (CTRL+SHIFT+p) aus Cmake: Select a Kit ausführst. Wähle hier am besten ein GCC11 Kit aus. Benutze nun den Build-Button unten links in der IDE. Dies sollte den Code kompilieren.

Solltest du den Code ändern, muss der Build-Button erneut gedrückt werden, sodass keine veraltete Version des Programms verwendet wird.

Die CMakeLists.txt enthält ein paar Hinweise, wodurch man das Projekt leicht um weitere Quelldateien erweitern kann. Werfen darauf einen Blick und spiele ein bisschen damit herum.

Wenn du mehr über CMake wissen willst, und wie man eine CMakeLists.txt schreibt, die deine Bedürfnissen am besten umsetzt, schaue dir diese Links an:

Ausführen und Debuggen

Im letzten Schritt haben wir eine ausführbare Binärdatei für unser kleines Projekt erstellt. Wir schauen uns nun an, wie wir unser Programm von VSCode aus ausführen und debuggen können.

  1. Wähle Run and Debug im linken Panel.
  2. Wähle dann create a launch.json file.
  3. Füge die folgende Konfiguration ein:
{
    "name": "hello debug",
    "type": "cppdbg",
    "request": "launch",
    "program": "${workspaceFolder}/build/Hello",
    "args": [],
    "stopAtEntry": false,
    "cwd": "${fileDirname}",
    "environment": [],
    "externalConsole": false,
    "MIMode": "gdb",
    "setupCommands": [
        {
            "description": "Enable pretty-printing for gdb",
            "text": "-enable-pretty-printing",
            "ignoreFailures": true
        }
    ]

}

Du solltest nun in der Lage sein, die Konfiguration hello debug aus dem run and debug Dropdown-Menü auszuwählen. Starte das Programm. Wer hätte es gedacht: das Programm gibt “Hello World” aus!

Zu guter Letzt wollen wir noch einen kurzen Blick auf den Debugger werfen. Öffne die Datei hello.c und setze einen Breakpoint in der Zeile mit der printf-Anweisung.

Wenn wir das Programm nun erneut ausführen, wird es vor der Ausführung der Codezeile, in der sich der Breakpoint befindet, pausieren.

Ein Debugger ist ein unglaublich mächtiges Entwicklungswerkzeug. Wir werden hier nur das Notwendigste zu seiner Verwendung überfliegen. Wir empfehlen dir zwar, mehr über das Debugging zu lesen, aber dies ist bereits eine große Hilfe, die dir unglaublich viel Zeit sparen wird.

Auf der linken Seite ist eine (etwas leere) Box mit der Überschrift Variables.

Im Moment haben wir noch keine Variablen. Sollten wir unser Programm so ändern, dass es Variablen verwendet, werden wir eine Übersicht über unsere Variablen und deren Inhalt sehen können.

Außerdem wird die IDE während der Ausführung ein kleines breites Fenster einblenden.

Die wichtigste Taste für dich ist die Step Over Taste, mit der du dein Programm Schritt für Schritt ausführen kannst. Wenn du ihn drückst, wirst du sehen, dass die printf-Anweisung ausgeführt wird und das Programm beendet wird.

Lese hier mehr über Run Konfigurationen und den Debugger: