---
title: "C und C++ Compiler installieren: Windows, Linux \u0026 macOS"
description: "Lerne, wie du GCC mit MSYS2 (Windows), build-essential (Linux) oder Xcode (macOS) installierst und in VS Code nutzt."
url: "https://www.alemasone.com/de/c-cpp-compiler-installieren-windows-linux-macos/"
language: "de"
published: 2024-07-20
updated: 2026-09-19
categories: ["Programmierung Und Entwicklung"]
translations:
it: "https://www.alemasone.com/it/installare-gcc-windows-linux-macos/"
en: "https://www.alemasone.com/en/install-c-cpp-compilers-windows-linux-macos/"
es: "https://www.alemasone.com/es/instalar-compilador-c-cpp-windows-linux-macos/"
fr: "https://www.alemasone.com/fr/installer-compilateur-c-cpp-windows-linux-macos/"
pt: "https://www.alemasone.com/pt/instalar-compilador-c-cpp-windows-linux-macos/"
---
# C und C++ Compiler installieren: Windows, Linux & macOS
Auf Linux und macOS wird der Compiler mit einem Befehl installiert. Unter Windows ist der richtige Weg heute **MSYS2**, das dir GCC über MinGW-w64 bereitstellt und es automatisch aktualisiert. Das alte MinGW von SourceForge – das mit dem Installation Manager, den man in vielen Anleitungen findet (auch in der ersten Version dieser hier) – ist seit Jahren veraltet, erstellt nur 32-Bit-Programme und sollte nicht mehr verwendet werden.
Der Compiler wandelt den Quellcode in ein ausführbares Programm um. Für C und C++ sind die beiden am häufigsten verwendeten: **GCC**, seit 1987 im Einsatz und überall verfügbar, und **[Clang](https://clang.llvm.org/)**, der jüngere mit klareren Fehlermeldungen, der unter macOS standardmäßig installiert ist. Die neueste Version von GCC ist die 16 (erschienen im April 2026), die für C++ standardmäßig den C++20-Standard verwendet.
Im Folgenden findest du die Installation für alle drei Systeme, die Befehle zum Kompilieren und die Konfiguration von Visual Studio Code.
## Windows: MSYS2 und MinGW-w64
[MinGW-w64](https://www.mingw-w64.org/) ist die GCC-Version, die native Executables für Windows erstellt. MSYS2 ist die Umgebung, die sie bereitstellt und aktuell hält.
1. Lade das Installationsprogramm von der [offiziellen MSYS2-Website](https://www.msys2.org/) herunter und installiere es mit dem Standardpfad `C:\msys64`.
2. Nach Abschluss öffnet sich ein MSYS2-Terminal. Aktualisiere die Basis-Pakete:
```bash
pacman -Syu
```
Wenn sich das Fenster während des Updates schließt, keine Sorge: Öffne es einfach über das Startmenü neu (**MSYS2 UCRT64**) und wiederhole den Befehl, bis nichts mehr zu aktualisieren ist.
3. Installiere die 64-Bit-Build-Tools:
```bash
pacman -S mingw-w64-ucrt-x86_64-toolchain
```
Wenn du gefragt wirst, welche Pakete installiert werden sollen, drücke Enter, um alle auszuwählen, und bestätige dann mit Y. Falls du auch einen Debugger benötigst: Er ist bereits enthalten: `gdb` gehört zur Gruppe dazu.
4. Füge den Ordner der Compiler zum Windows-PATH hinzu, damit du sie in jedem Terminal nutzen kannst. Suche im Startmenü nach **Systemumgebungsvariablen bearbeiten** (oder gehe zu **Einstellungen** → **System** → **Info** → **Erweiterte Systemeinstellungen**), klicke auf **Umgebungsvariablen**, wähle `Path` unter den Benutzervariablen aus, dann auf **Bearbeiten** → **Neu** und gib Folgendes ein:
```text
C:\msys64\ucrt64\bin
```
5. Bestätige alles mit **OK**, öffne eine **neue** Eingabeaufforderung (CMD) und überprüfe es:
```bat
gcc --version
g++ --version
```
> **Es gibt auch kürzere Wege.** **[w64devkit](https://github.com/skeeto/w64devkit)** ist ein einzelnes Archiv zum Entpacken, ganz ohne Paketmanager: praktisch, wenn man es nur gelegentlich nutzt. Und wenn du unter Windows nur C lernen willst, ist auch das [Windows-Subsystem für Linux (WSL)](https://learn.microsoft.com/it-it/windows/wsl/) super: Installiere [Ubuntu](/de/wine-unter-ubuntu-installieren/) mit `wsl --install` und folge dem Linux-Teil weiter unten.
## Linux
Bei Debian, Ubuntu und deren Derivaten ist alles Nötige in einem einzigen Paket enthalten:
```bash
sudo apt update
sudo apt install build-essential gdb
```
Darin sind GCC, G++, make und die Development-Libraries enthalten. Auf Fedora:
```bash
sudo dnf install gcc gcc-c++ make gdb
```
Auf Arch Linux:
```bash
sudo pacman -S base-devel gdb
```
Überprüfe es mit `gcc --version`. Du brauchst sonst nichts weiter: Die Pfade sind bereits konfiguriert.
## macOS
Auf dem [Mac ist der Standard-Compiler](/de/virtualisierung-apple-silicon-windows-linux-macos/) Clang, der mit den Xcode Command Line Tools kommt. Installiere sie mit diesem Befehl, der ein Bestätigungsfenster öffnet:
```bash
xcode-select --install
```
Von hier an existieren die Befehle `gcc` und `g++` zwar, führen aber eigentlich Clang aus. Für das Lernen macht das keinen Unterschied.
Falls du unbedingt GCC brauchst, zum Beispiel für ein Projekt, das dies erfordert, installiere es mit [Homebrew](https://brew.sh/):
```bash
brew install gcc
```
Die Befehle werden `gcc-16` und `g++-16` heißen (mit der Versionsnummer), damit sie sich nicht mit den Systembefehlen überschneiden.
## Kompilieren über das Terminal
Die Befehle sind überall gleich, nur der Name der erzeugten Datei ändert sich.
Eine einzelne C-Datei kompilieren:
```bash
gcc programma.c -o programma
```
C++ kompilieren mit einem aktuellen Standard und allen Warnungen:
```bash
g++ -std=c++20 -Wall -Wextra programma.cpp -o programma
```
Das Ergebnis ausführen:
```bash
./programma
```
Unter Windows heißt die Executable in der Eingabeaufforderung `programma.exe` und wird durch Eingabe von `programma` gestartet.
Wichtige Optionen für den Anfang:
| Option | Funktion |
|---------|---------|
| `-Wall -Wextra` | Zeigt Warnungen an: Sie fangen Fehler ab, die der Compiler sonst stillschweigend akzeptieren würde |
| `-g` | Schließt Debug-Informationen ein, die für die Nutzung des Debuggers notwendig sind |
| `-O2` | Optimiert den Code; sollte für die finale Version genutzt werden, nicht während der Entwicklung |
| `-std=c++20` | Legt den Sprachstandard fest, um Unterschiede zwischen verschiedenen Computern zu vermeiden |
> **Ab mehr als drei Dateien: Vergiss das manuelle Kompilieren.** Schreibe ein `Makefile` oder nutze [CMake](https://cmake.org/). Alles bei jeder Änderung neu zu kompilieren kostet Zeit, und früher oder später vergisst man eine Datei und verbringt eine halbe Stunde mit einem Fehler, der gar nicht existiert.
## Visual Studio Code konfigurieren
Visual Studio Code hat keinen eigenen Compiler: Es nutzt den, den du installiert hast. Das ist in zwei Schritten erledigt.
1. Installiere die Microsoft-Erweiterung **[C/C++](https://code.visualstudio.com/docs/languages/cpp)** über das Seitenmenü für Erweiterungen. Alternativ gibt es **[clangd](https://clangd.llvm.org/)**, das beim Autocomplete und bei Warnmeldungen schneller ist.
2. Öffne den Projektordner und erstelle eine Quelldatei. Drücke F5: Beim ersten Ausführen fragt der Editor, welchen Compiler du verwenden möchtest, und erstellt die Dateien `tasks.json` und `launch.json` automatisch im Unterordner `.vscode`.
Falls der Compiler nicht in der Liste erscheint, liegt das unter Windows meist am PATH. Überprüfe, ob `gcc --version` in einem neuen Terminal funktioniert, und starte den Editor danach komplett neu: Die Umgebungsvariablen werden erst beim Start eingelesen.
Um ohne den Debugger zu kompilieren, akzeptiert das integrierte Terminal (Strg + ò) dieselben Befehle wie oben beschrieben.
## Häufige Fehler
**`gcc non è riconosciuto come comando`** unter Windows: Der Ordner `bin` ist nicht in der Variable PATH enthalten oder das Terminal war bereits geöffnet, als du ihn hinzugefügt hast.
**`fatal error: iostream: No such file or directory`**: Du kompilierst eine C++-Datei mit `gcc` anstatt mit `g++`.
**Du hast zwei verschiedene GCC-Versionen**: Wenn sich die alte Version von `C:\MinGW\bin` noch im PATH befindet, entferne diesen Eintrag, sonst findet Windows unter Umständen zuerst die veraltete Version. `where gcc` zeigt dir an, welche verwendet wird.
**`undefined reference to ...`**: Das Kompilieren war erfolgreich, aber es fehlt die Verknüpfung zu einer Library oder einer anderen Quelldatei. Wenn es mehr als eine Datei ist, müssen alle angegeben werden oder du nutzt ein Build-System.
**Die .exe startet auf einem anderen Windows-PC nicht**: Es fehlen die Runtime-Bibliotheken. Das lässt sich lösen, indem du mit `-static` kompilierst, da diese dann direkt in der ausführbaren Datei enthalten sind.
## Häufig gestellte Fragen
### Sind MinGW und MSYS2 dasselbe?
Nein. MinGW-w64 ist das Toolset, das es GCC ermöglicht, Programme für Windows zu erstellen; MSYS2 ist die Umgebung, die diese bereitstellt, aktualisiert und ein Unix-ähnliches Terminal bietet. Heutzutage installiert man MSYS2 primär, um eine aktuelle Version von MinGW-w64 zu erhalten.
### GCC oder Clang: Was soll ich wählen?
Zum Lernen sind beide gut geeignet. Clang ist unter macOS vorinstalliert und liefert klarere Fehlermeldungen, was am Anfang sehr hilfreich ist. GCC ist der Standard unter Linux und begegnet dir in bestehenden Projekten häufiger. Viele Entwickler nutzen beide: Das Kompilieren mit zwei verschiedenen Compilern kann Fehler aufdecken, die einer von beiden übersehen würde.
### Kann ich immer noch das alte MinGW von SourceForge verwenden?
Es funktioniert zwar, wird aber seit Jahren nicht mehr aktualisiert, erstellt nur 32-Bit-Programme und hinkt aktuellen C++-Standards hinterher. Wenn du es bereits installiert hast, deinstalliere es, entferne `C:\MinGW\bin` aus dem PATH und wechsle zu MSYS2.
### Kann ich Windows-Programme unter Linux kompilieren?
Ja, indem du die Cross-Compiler-Version von MinGW-w64 installierst, die in den meisten Distributionen als Paket verfügbar ist. Du kompilierst mit `x86_64-w64-mingw32-gcc` und erhältst eine funktionierende `.exe`, was nützlich ist, um ein Programm zu verteilen, ohne einen Windows-Rechner zu besitzen.
### Brauche ich Visual Studio anstelle von Visual Studio Code?
Das sind zwei verschiedene Dinge. Visual Studio ist eine vollständige Entwicklungsumgebung mit dem eigenen Microsoft-Compiler (MSVC), während Visual Studio Code ein Editor ist, der den Compiler nutzt, den du ihm vorgibst. Um C und C++ zu lernen, reicht der Editor mit GCC völlig aus und ist wesentlich leichtgewichtiger.
### Wie installiert man einen Debugger?
Unter Linux und mit MSYS2 wird `gdb` zusammen mit dem Compiler installiert, wie oben gezeigt. Auf macOS nutzt du `lldb`, das bereits in den Xcode-Tools enthalten ist. In beiden Fällen erkennt Visual Studio Code ihn automatisch, sobald die Startkonfiguration generiert wurde.