Setup

Diese Anleitung beschreibt die Installation einer Entwicklungsumgebung für die Programmiersprache C, die auf Debian 13 “Trixie” GNU/Linux basiert.

WSL (Debian 13 “Trixie”)

Das Windows-Subsystem für Linux (WSL) erlaubt den nahtlosen Betrieb von einem Linux-Betriebssystem unter Windows. Zunächst muss WSL installiert werden. Gehe hierzu folgendermassen vor:

• Betätige die Windows-Taste auf der Tastatur.
• Tippe PowerShell ein.
• Mache einen Rechtsklick auf das Icon und wähle Als Administrator ausführen an.

Im Konsolenfenster kannst du nun den folgenden Befehl eingeben:

wsl --install -d Debian

Die Installation dauert einige Minuten. Anschliessend sollte folgender Bildschirm angezeigt werden:

• Verwende deinen Vornamen in Kleinbuchstaben als Benutzername, z.B. patrick.
• Wähle ein Passwort aus, das leicht einzutippen ist. (Hier geht es mehr um den Anwenderkomfort als um die Sicherheit.)

Nach erfolgter Einrichtung siehst du diesen Bildschirm:

Mit dem cd-Befehl gelangt man in sein Heimverzeichnis.

Dateiaustausch

Im Windows-Explorer findest du unten links nun das Icon Linux, welches das Dateisystem von Debian enthält:

Wenn du nach home, [Benutzername] (z.B. patrick) navigierst, siehst du den Inhalt deines Heimverzeichnisses:

Damit wäre Debian unter WSL vorerst fertig eingerichtet.

Weitere Installationshinweise finden sich auf der WSL-Installationsseite von Microsoft.

Pakete installieren

Als nächstes müssen einige Software-Pakete installiert werden. Dies sind:

1. Ein C-Compiler mit verschiedensten Hilfswerkzeugen: build-essential
2. Ein einfacher Texteditor für die Kommandozeile: nano
3. Die Versionskontrollsoftware Git: git

Software-Pakete können unter Debian mit dem Befehl apt install installiert werden. Es können gleich mehrere Paketnamen auf einmal mitgegeben werden. Führe nun folgenden Befehl aus:

sudo apt install -y build-essential nano git

Mithilfe von sudo erhält man temporär Administratorenrechte. Darum muss das vorher gewählte Passwort eingegeben werden.

Anschliessend kannst du die Installation der einzelnen Pakete mit den folgenden Befehlen überprüfen:

gcc --version
nano --version
git --version

Die Ausgabe sollte dann ungefähr so aussehen:

Die angezeigten Versionsnummern können sich dabei leicht unterscheiden.

Der Texteditor Nano

Nano ist ein sehr einfacher Texteditor für die Konsole. Auf der Webseite findet man u.a. eine komplette Anleitung und eine Befehlsübersicht.

Zu Beginn brauchen wir aber nur einige wenige Befehle. Wir wollen eine Datei namens introduction.txt erstellen, wozu du den folgenden Befehl ausführen musst:

nano introduction.txt

Es sollte nun ein Fenster erscheinen, das ungefähr so aussieht:

Gib nun etwas Text ein, z.B. eine kleine Vorstellung von dir:

Hallo, mein Name ist Patrick, und ich programmiere gerne.

Mit Ctrl-S kannst du die Datei speichern. Mit Ctrl-X kannst du den Texteditor wieder verlassen.

Konfiguration

Nano wird in einer Konfigurationsdatei namens .nanorc im Heimverzeichniss konfiguriert. Öffne diese Datei unter nano mit folgendem Befehl:

nano .nanorc

Nun kannst du folgende Konfiguration eingeben:

set autoindent
set tabsize 4
set linenumbers
include "/usr/share/nano/*.nanorc"

Speichere und schliesse den Texteditor mit Ctrl-S und Ctrl-X.

Die Einstellungen bedeuten das folgende:

1. automatische Einrückung
2. Einrückung mit vier Zeichen
3. Zeilennummern anzeigen
4. Verwendung von Syntax-Hervorhebung in allen vorhandenen Sprachen

Damit wäre nano fürs erste ausreichend konfiguriert.

Die Versionskontrolle Git

Damit wir verschiedene Versionen von einer Datei verwalten können, benötigen wir die etablierte Versionsverwaltung Git. Diese schauen wir uns im Modul 426 genauer an. An dieser Stelle wollen wir nur die wichtigsten Handgriffe für den Anfang lernen.

Konfiguration

Zunächst muss Git grundlegend konfiguriert werden. Wir müssen den vollen Namen sowie die E-Mail-Adresse hinterlegen, damit wir Einträge in der Versionsgeschichte festhalten können.

Ein Benutzer namens “John Doe” mit SLUZ-Account müsste folgende Befehle eingeben:

git config --global user.name "John Doe"
git config --global user.email "john_doe@sluz.ch"

Passe Name und E-Mail-Adresse auf deine Angaben an und führe damit die obenstehenden Befehle aus. Anschliessend kannst du die Einstellunen folgendermassen überprüfen:

git config user.name
git config user.email

Das Ergebnis sollte folgendermassen aussehen, natürlich mit deinen persönlichen Angaben:

Repository erstellen

Git verwaltet Quellcode in einem sogenannten Repository. Wir wollen ein neues Repository namens hello-world erstellen, wozu wir zunächst ein gleichnamiges Verzeichnis anlegen:

mkdir hello-world

Anschliessend wechseln wir das Arbeitsverzeichnis dorthin:

cd hello-world

In diesem leeren Verzeichnis erstellen wir ein Repository:

git init

Dateien sichern: Das erste C-Programm

Wir erstellen nun gleich unser erstes C-Programm. Starte dazu nano folgendermassen:

nano hello.c

Tippe nun den folgenden Programmcode selber ein. So kannst du sicherstellen, dass du alle darin vorkommenden Sonderzeichen auf der Tastatur findest:

#include <stdio.h>

int main(int argc, char *argv[]) {
    printf("Hello, World!\n");
    return 0;
}

Das ganze sollte nun etwa so aussehen:

Speichere die Datei ab und schliesse den Texteditor.

Wir wollen diese Datei nun in die Versionskontrolle aufnehmen.

Gib zuerst den folgenden Befehl ein, der den Zustand des Repositories ausgibt:

git status

Die Ausgabe sollte etwa folgendermassen aussehen:

Merke die Datei nun für den nächsten Commit (Schreibvorgang) vor:

git add hello.c

Kontrolliere den Vorgang, indem du erneut diesen Befehl ausführst:

git status

Nun sollte die Ausgabe folgendermassen aussehen:

Mit dem folgenden Befehl wird die Datei definitiv ins Repository geschrieben:

git commit -m "first C program"

Mit dem Parameter -m geben wir einen Änderungskommentar mit. Dieser erscheint, wenn wir die Versionsgeschichte mit folgendem Befehl ausgeben lassen:

git log

Die Ausgabe sollte ungefähr folgendermassen aussehen:

Der GNU C Compiler (GCC)

Wir haben nun den Programmcode in der Datei hello.c. Dieser ist jedoch nicht ausführbar. Um zu einem ausführbaren Programm zu kommen, müssen wir den Programmcode zuerst kompilieren. Hierzu haben wir den GNU C Compiler (gcc) installiert.

Erstes Programm kompilieren

Damit lässt sich das Programm folgendermassen kompilieren:

gcc hello.c -o hello

Falls es zu einem Fehler kommen sollte, kontrolliere noch einmal, ob du den Code richtig abgetippt hast, und korrigiere allfällige Fehler, bis das Programm kompiliert werden kann.

Der Befehl bedeutet folgendes: “Kompiliere die Datei hello.c und gib sie als Datei hello aus (-o steht für output).

Anschliessend sollten zwei Dateien im Verzeichnis sein, was man mit dem Befehl ls überprüfen kann:

Die Datei hello kann nun folgendermassen ausgeführt werden:

./hello

Hierbei sollte die folgende Ausgabe erscheinen:

Herzliche Gratulation! Du hast dein erstes C-Programm zur Ausführung gebracht!

Aufgaben

1. Schreibe ein weiteres C-Programm, das deinen Namen ausgibt.
2. Kompiliere das Programm und starte es.
3. Wenn das Programm funktioniert, kannst du den Programmcode per Git ins Repository aufnehmen.

Zusatzaufgabe

Falls du mit allem fertig bist, kannst du dich im Wikibook über C-Programmierung etwas in die Thematik einlesen.

Weitere Hinweise

Wenn die Debian-Umgebung nicht mehr funktioniert, kann sie mit folgendem Befehl entfernt werden:

wsl --unregister Debian