---
title: "Installer un compilateur C et C++ sur Windows, Linux et macOS"
description: "Apprenez à installer GCC avec MSYS2 sur Windows, build-essential sur Linux et Xcode sur macOS, ainsi que la configuration de VS Code."
url: "https://www.alemasone.com/fr/installer-compilateur-c-cpp-windows-linux-macos/"
language: "fr"
published: 2024-07-20
updated: 2026-09-19
categories: ["Programmation Et Développement"]
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/"
  pt: "https://www.alemasone.com/pt/instalar-compilador-c-cpp-windows-linux-macos/"
  de: "https://www.alemasone.com/de/c-cpp-compiler-installieren-windows-linux-macos/"
---

# Installer un compilateur C et C++ sur Windows, Linux et macOS

Sur Linux et macOS, le compilateur s'installe avec une commande. Sur Windows, la bonne méthode aujourd'hui est **MSYS2**, qui vous fournit GCC via MinGW-w64 et assure sa mise à jour automatique. L'ancien MinGW de SourceForge, celui avec l'Installation Manager que l'on trouve dans de nombreux guides (y compris dans la première version de celui-ci), n'est plus mis à jour depuis des années, ne produit que des programmes 32 bits et ne doit plus être utilisé.

Le compilateur transforme le code source en un programme exécutable. Pour le C et le C++, les deux plus utilisés sont : **GCC**, présent depuis 1987 et disponible partout, et **[Clang](https://clang.llvm.org/)**, plus récent, avec des messages d'erreur plus clairs et installé par défaut sur macOS. La dernière version de GCC est la 16, sortie en avril 2026, qui utilise par défaut le standard C++20 pour le C++.

Vous trouverez ci-dessous l'installation pour les trois systèmes, les commandes pour compiler et la configuration de Visual Studio Code.

## Windows : MSYS2 et MinGW-w64

[MinGW-w64](https://www.mingw-w64.org/) est la version de GCC qui produit des exécutables natifs pour Windows. MSYS2 est l'environnement qui le distribue et le maintient à jour.

1. Téléchargez le programme d'installation sur le [site officiel de MSYS2](https://www.msys2.org/) et installez-le en laissant le chemin par défaut `C:\msys64`.

2. Une fois terminé, un terminal MSYS2 s'ouvre. Mettez à jour les paquets de base :

   ```bash
   pacman -Syu
   ```

   Si la fenêtre se ferme pendant la mise à jour, ne vous inquiétez pas : rouvrez-la via le menu Démarrer (**MSYS2 UCRT64**) et répétez la commande jusqu'à ce qu'il n'y ait plus rien à mettre à jour.

3. Installez le groupe d'outils de compilation 64 bits :

   ```bash
   pacman -S mingw-w64-ucrt-x86_64-toolchain
   ```

   Lorsqu'on vous demande quels paquets installer, appuyez sur <kbd>Entrée</kbd> pour tous les prendre, puis confirmez avec <kbd>Y</kbd>. Si vous avez aussi besoin du debugger, il est déjà inclus : `gdb`il fait partie du groupe.

4. Ajoutez le dossier des compilateurs au PATH de Windows afin de pouvoir les utiliser depuis n'importe quel terminal. Recherchez **Modifier les variables d'environnement système** dans le menu Démarrer (ou allez dans **Paramètres** → **Système** → **À propos** → **Paramètres avancés du système**), cliquez sur **Variables d'environnement**, sélectionnez `Path` parmi les variables utilisateur, puis **Modifier** → **Nouveau** et écrivez :

   ```text
   C:\msys64\ucrt64\bin
   ```

5. Confirmez avec **OK** dans toutes les fenêtres, ouvrez un **nouveau** Invite de commandes et vérifiez :

   ```bat
   gcc --version
   g++ --version
   ```

![Fenêtre des Variables d'environnement Windows avec l'entrée Path parmi les variables utilisateur](variabili-ambiente-windows-compilazione-c.png "L'entrée Path à modifier se trouve dans le cadre des variables utilisateur")

> **Il existe aussi des solutions plus rapides.** **[w64devkit](https://github.com/skeeto/w64devkit)** est une archive unique à décompresser, sans gestionnaire de paquets : pratique si vous l'utilisez occasionnellement. Et si vous voulez seulement apprendre le C sur Windows, le [Sous-système Windows pour Linux](https://learn.microsoft.com/it-it/windows/wsl/) convient parfaitement : installez [Ubuntu](/fr/installer-wine-ubuntu-logiciels-windows/) avec `wsl --install` et suivez la partie Linux ci-dessous.

## Linux

Sur Debian, Ubuntu et leurs dérivées, tout ce dont vous avez besoin se trouve dans un seul paquet :

```bash
sudo apt update
sudo apt install build-essential gdb
```

On y trouve GCC, G++, make et les bibliothèques de développement. Sur Fedora :

```bash
sudo dnf install gcc gcc-c++ make gdb
```

Sur Arch Linux :

```bash
sudo pacman -S base-devel gdb
```

Vérifiez avec `gcc --version`. Rien d'autre n'est nécessaire : les chemins sont déjà configurés.

## macOS

Sur [Mac, le compilateur par défaut](/fr/virtualisation-mac-apple-silicon-windows-linux/) est Clang, qui est fourni avec les outils en ligne de commande d'Xcode. Installez-les avec cette commande, qui ouvre une fenêtre de confirmation :

```bash
xcode-select --install
```

À partir de là, les commandes `gcc` et `g++` existent, mais elles lancent en réalité Clang. Pour l'apprentissage, cela ne change rien.

Si vous avez absolument besoin de GCC, par exemple pour un projet qui l'exige, installez-le avec [Homebrew](https://brew.sh/) :

```bash
brew install gcc
```

Les commandes s'appelleront `gcc-16` et `g++-16`, suivies du numéro de version, afin de ne pas entrer en conflit avec celles du système.

## Compiler depuis le terminal

Les commandes sont les mêmes partout, seul le nom du fichier produit change.

Compiler un fichier C unique :

```bash
gcc programma.c -o programma
```

Compiler du C++, en demandant un standard récent et tous les avertissements :

```bash
g++ -std=c++20 -Wall -Wextra programma.cpp -o programma
```

Exécuter le résultat :

```bash
./programma
```

Sur Windows, depuis l'Invite de commandes, l'exécutable s'appelle `programma.exe` et se lance en tapant `programma`.

![Terminal qui compile un fichier C++ avec g++ et exécute immédiatement après le résultat](terminale-compilazione-cpp-g.png "Compilation sans erreur : aucun message, et le programme se lance")

Les options à connaître dès le début :

| Option | Rôle |
|---------|---------|
| `-Wall -Wextra` | Affiche les avertissements : ils interceptent les erreurs que le compilateur accepterait silencieusement |
| `-g` | Inclut les informations de débogage, nécessaires pour utiliser le debugger |
| `-O2` | Optimise le code ; à utiliser pour la version finale, pas pendant le développement |
| `-std=c++20` | Fixe le standard du langage, évitant ainsi les surprises entre différents ordinateurs |

> **Au-delà de trois fichiers, oubliez la compilation manuelle.** Écrivez un `Makefile` ou utilisez [CMake](https://cmake.org/). Recompiler tout à chaque modification fait perdre du temps, et tôt ou tard, on oublie un fichier et on passe une demi-heure sur une erreur qui n'existe pas.

## Configurer Visual Studio Code

Visual Studio Code ne possède pas son propre compilateur : il utilise celui que vous avez installé. Deux étapes suffisent.

1. Installez l'extension **[C/C++](https://code.visualstudio.com/docs/languages/cpp)** de Microsoft depuis le panneau des extensions. Alternativement, il existe **[clangd](https://clangd.llvm.org/)**, plus rapide pour l'autocomplétion et les avertissements.

2. Ouvrez le dossier du projet et créez un fichier source. Appuyez sur <kbd>F5</kbd> : lors de la première exécution, l'éditeur vous demandera quel compilateur utiliser et générera automatiquement les fichiers `tasks.json` et `launch.json` dans le sous-dossier `.vscode`.

Si le compilateur n'apparaît pas dans la liste, sur Windows, le coupable est généralement le PATH. Vérifiez que `gcc --version` fonctionne dans un nouveau terminal, puis fermez et redémarrez complètement l'éditeur : il ne lit les variables d'environnement qu'au démarrage.

![Visual Studio Code demande quel compilateur utiliser lors du premier lancement du débogage](vscode-selezione-compilatore-c.png "Lors de la première exécution, l'éditeur liste les compilateurs qu'il a trouvés sur le système")

Pour compiler sans le débogueur, le terminal intégré (<kbd>Ctrl</kbd> + <kbd>ò</kbd>) accepte les mêmes commandes que celles vues précédemment.

## Erreurs fréquentes

**`gcc non è riconosciuto come comando`** sur Windows : le dossier `bin` n'est pas dans la variable PATH, ou bien le terminal était déjà ouvert lorsque vous l'avez ajouté.

**`fatal error: iostream: No such file or directory`**: vous compilez un fichier C++ avec `gcc` au lieu de `g++`.

**Vous avez deux versions de GCC différentes** : si l'ancienne version de `C:\MinGW\bin` est toujours présente dans le PATH, supprimez cette ligne, sinon Windows pourrait utiliser la version obsolète en priorité. `where gcc` vous indique laquelle est utilisée.

**`undefined reference to ...`**: la compilation a réussi mais il manque le lien vers une bibliothèque ou un autre fichier source. Lorsque plusieurs fichiers sont impliqués, ils doivent tous être indiqués, ou alors utilisez un système de build.

**L'exécutable ne se lance pas sur un autre ordinateur Windows** : les bibliothèques de runtime sont manquantes. Cela se résout en compilant avec `-static`, qui les inclut dans l'exécutable.

## Foire aux questions

### MinGW et MSYS2 sont-ils la même chose ?

Non. MinGW-w64 est l'ensemble d'outils qui permet à GCC de produire des programmes pour Windows ; MSYS2 est l'environnement qui les distribue, les met à jour et fournit un terminal de style Unix. Aujourd'hui, on installe MSYS2 précisément pour obtenir une version à jour de MinGW-w64.

### GCC ou Clang : lequel choisir ?

Pour apprendre, les deux conviennent. Clang est celui installé par défaut sur macOS et propose des messages d'erreur plus clairs, ce qui aide énormément au début. GCC est le standard sur Linux et vous le trouverez plus souvent dans les projets existants. De nombreux développeurs utilisent les deux : compiler avec deux compilateurs différents permet de faire ressortir des erreurs qu'un seul laisserait passer.

### Puis-je encore utiliser l'ancien MinGW de SourceForge ?

Il fonctionne, mais il n'est plus mis à jour depuis des années, ne crée que des programmes 32 bits et est en retard sur les standards récents du C++. Si vous l'avez déjà installé, désinstallez-le, retirez `C:\MinGW\bin` du PATH et passez à MSYS2.

### Puis-je compiler des programmes Windows depuis Linux ?

Oui, en installant la version cross-compilation de MinGW-w64, disponible sous forme de paquet dans les principales distributions. On compile avec `x86_64-w64-mingw32-gcc` pour obtenir un `.exe` fonctionnel, ce qui est très utile pour distribuer un programme sans posséder d'ordinateur Windows.

### Faut-il utiliser Visual Studio à la place de Visual Studio Code ?

Ce sont deux choses différentes. Visual Studio est un environnement de développement complet avec son propre compilateur Microsoft (MSVC), tandis que Visual Studio Code est un éditeur qui utilise le compilateur que vous lui fournissez. Pour apprendre le C et le C++, l'éditeur avec GCC suffit amplement et il est beaucoup plus léger.

### Comment installer un débogueur ?

Sur Linux et avec MSYS2, on installe `gdb` en même temps que le compilateur, comme illustré précédemment. Sur macOS, on utilise `lldb`, déjà inclus dans les outils Xcode. Dans les deux cas, Visual Studio Code le reconnaît automatiquement lors de la génération de la configuration de lancement.
