🔝 Retour au Sommaire
Chapitre 2 · Section 2.4 · Configuration de l'IDE · Niveau Débutant
VS Code est un éditeur volontairement minimaliste : hors extensions, il ne sait pas compiler du C++, ne comprend pas CMake et n'offre aucune autocomplétion sémantique. Toute l'intelligence vient des extensions. Le choix et la configuration de ces extensions déterminent la qualité de votre expérience quotidienne.
Cette section détaille les extensions indispensables pour un workflow C++ professionnel sur Ubuntu, leur configuration optimale, et la résolution des conflits courants entre elles.
Commencez par installer les quatre extensions essentielles en une seule commande :
code --install-extension llvm-vs-code-extensions.vscode-clangd
code --install-extension ms-vscode.cmake-tools
code --install-extension ms-vscode.cpptools
code --install-extension twxs.cmake Vérifiez l'installation dans VS Code : ouvrez la vue Extensions (Ctrl+Shift+X) et confirmez que les quatre apparaissent dans la section « Installed ».
Identifiant : llvm-vs-code-extensions.vscode-clangd
Éditeur : LLVM
Cette extension connecte VS Code au serveur de langage clangd (voir section 2.4). C'est elle qui fournit :
- L'autocomplétion sémantique — des suggestions qui comprennent le type de chaque variable, même à travers des templates imbriqués, des
autoet des expressions lambda. Contrairement à un moteur basé sur des heuristiques, clangd utilise le même parser que le compilateur Clang. - Les diagnostics en temps réel — les erreurs et warnings apparaissent dans l'éditeur à mesure que vous tapez, sans avoir à lancer la compilation. Les diagnostics sont identiques à ceux que
clang++produirait. - La navigation dans le code — « Go to Definition » (
F12), « Go to Declaration » (Ctrl+F12), « Find All References » (Shift+F12), « Go to Symbol » (Ctrl+T). Ces fonctionnalités fonctionnent à travers tout le projet, y compris dans les headers de la bibliothèque standard. - Le renommage intelligent —
F2renomme un symbole dans tout le projet, en tenant compte de la sémantique (seules les occurrences du même symbole sont renommées, pas les homonymes). - Les inlay hints — affichage discret des types déduits par
auto, des noms de paramètres dans les appels de fonctions, et des types de retour des lambdas. Très utile pour le code C++ moderne qui utilise intensivement la déduction de type. - Le formatage automatique — clangd intègre
clang-formatet peut formater le code à la sauvegarde ou à la demande. - Les code actions — suggestions de corrections rapides (quick-fixes) : ajout d'un
#includemanquant, application d'un fix-it de clang-tidy, extraction de variable, etc.
Les paramètres de l'extension se configurent dans le settings.json de VS Code (Ctrl+Shift+P → « Preferences: Open User Settings (JSON) ») :
{
"clangd.path": "clangd",
"clangd.arguments": [
"--background-index",
"--clang-tidy",
"--header-insertion=iwyu",
"--completion-style=detailed",
"--function-arg-placeholders",
"--fallback-style=Google",
"--pch-storage=memory",
"-j=4"
],
"clangd.detectExtensionConflicts": true,
"clangd.enableCodeActions": true
}Détail des arguments :
--background-index — après l'ouverture du projet, clangd indexe tous les fichiers source en arrière-plan. L'index est sauvegardé sur disque (dans un répertoire .cache/clangd/ relatif au projet), ce qui rend les réouvertures suivantes quasi instantanées. Sans ce flag, clangd n'indexe que les fichiers ouverts — la navigation « Find All References » est alors limitée.
--clang-tidy — active l'analyse clang-tidy en plus des diagnostics du compilateur. Les checks actifs sont déterminés par le fichier .clang-tidy à la racine du projet (si présent) ou par la configuration dans le fichier .clangd. Cela fait apparaître les avertissements de modernisation, de performance et de bugs directement dans l'éditeur.
--header-insertion=iwyu — quand l'autocomplétion insère un symbole provenant d'un header non encore inclus, clangd ajoute automatiquement la directive #include correspondante en haut du fichier. Le mode iwyu (Include What You Use) privilégie l'inclusion directe du header qui déclare le symbole, plutôt que l'inclusion d'un header « parapluie » qui l'inclut transitivement.
--completion-style=detailed — les suggestions d'autocomplétion affichent les signatures complètes (types des paramètres, type de retour) plutôt qu'un simple nom de fonction. Plus verbeux mais beaucoup plus informatif.
--function-arg-placeholders — lors de l'autocomplétion d'un appel de fonction, clangd insère des placeholders (curseurs) pour chaque argument, permettant de les remplir en tabulant de l'un à l'autre.
--fallback-style=Google — style de formatage utilisé quand aucun fichier .clang-format n'est trouvé dans l'arborescence du projet. Les options courantes sont Google, LLVM, Chromium et Mozilla.
--pch-storage=memory — stocke les en-têtes précompilés en mémoire plutôt que sur disque, pour de meilleures performances. Consomme plus de RAM mais réduit les latences de complétion.
-j=4 — nombre de threads utilisés pour l'indexation en arrière-plan. Ajustez selon le nombre de cœurs de votre machine. Sur un poste 8 cœurs, -j=4 laisse de la marge pour le reste du système.
Si plusieurs versions de clangd sont installées, pointez vers la version souhaitée :
{
"clangd.path": "/usr/bin/clangd-20"
}Les inlay hints sont l'une des fonctionnalités les plus appréciées de clangd pour le C++ moderne. Ils affichent, directement dans le code et en grisé, des informations que le compilateur déduit mais que le développeur ne voit pas dans le source :
auto result = compute(42, "hello");
// ^^^^^^^^ inlay hint : « : std::expected<Data, Error> »
vec.emplace_back(name, age);
// ^^^^ ^^^ inlay hints : « name: », « age: »Pour activer ou désactiver les différents types de hints :
{
"editor.inlayHints.enabled": "onUnlessPressed",
"clangd.inlayHints.enabled": true
}Le mode "onUnlessPressed" affiche les hints par défaut et les masque quand vous maintenez Ctrl+Alt — un bon compromis entre informativité et lisibilité.
Identifiant : ms-vscode.cmake-tools
Éditeur : Microsoft
CMake Tools transforme VS Code en un environnement CMake complet. L'extension :
- Détecte automatiquement les
CMakeLists.txtet lesCMakePresets.jsondans le projet. - Fournit une interface graphique pour la configuration (choix du preset, du compilateur, du type de build).
- Lance les builds depuis VS Code (palette de commandes, barre de statut ou raccourci clavier).
- Sélectionne la cible à compiler et à exécuter/déboguer.
- Génère automatiquement le
compile_commands.jsonsiCMAKE_EXPORT_COMPILE_COMMANDSest activé.
{
"cmake.generator": "Ninja",
"cmake.configureOnOpen": true,
"cmake.buildDirectory": "${workspaceFolder}/build",
"cmake.configureSettings": {
"CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
"CMAKE_CXX_COMPILER_LAUNCHER": "ccache",
"CMAKE_C_COMPILER_LAUNCHER": "ccache"
},
"cmake.copyCompileCommands": "${workspaceFolder}/compile_commands.json",
"cmake.configureOnEdit": true,
"cmake.parallelJobs": 0
}Détail des options importantes :
cmake.generator — spécifie le générateur CMake. Utilisez "Ninja" pour les raisons décrites en section 2.2. CMake Tools utilisera automatiquement Ninja pour tous les builds.
cmake.configureOnOpen — quand vous ouvrez un dossier contenant un CMakeLists.txt, l'extension lance automatiquement la configuration CMake. Très pratique au quotidien.
cmake.configureSettings — dictionnaire de variables CMake passées automatiquement à chaque configuration. C'est ici que nous activons la génération du compile_commands.json et l'utilisation de ccache. Ces valeurs sont l'équivalent des -D... en ligne de commande.
cmake.copyCompileCommands — après chaque configuration, CMake Tools copie automatiquement le compile_commands.json du répertoire de build vers l'emplacement spécifié (ici, la racine du projet). Cela remplace le lien symbolique manuel que nous avons créé à la section 2.4 — plus propre et plus fiable, surtout quand le répertoire de build change.
cmake.configureOnEdit — relance automatiquement la configuration CMake quand le CMakeLists.txt est modifié et sauvegardé. Cela maintient le compile_commands.json à jour sans intervention manuelle.
cmake.parallelJobs — nombre de jobs parallèles pour la compilation. La valeur 0 signifie « automatique » (Ninja utilise tous les cœurs disponibles).
Après la configuration, CMake Tools ajoute plusieurs éléments à la barre de statut en bas de VS Code :
[ Ninja ] [ Debug ] [ GCC 15.2.0 ] [ mon_programme ] [ ▶ Build ] [ ▷ Run ]
- Build type (
Debug,Release, etc.) — cliquez pour changer. - Kit / Compilateur — cliquez pour choisir entre GCC et Clang.
- Target — la cible CMake à compiler (votre exécutable, une bibliothèque,
all). - Build — lance la compilation (
F7). - Run — lance l'exécutable (sans debugger).
Si votre projet contient un fichier CMakePresets.json, CMake Tools le détecte automatiquement et propose les presets dans la palette de commandes et dans la barre de statut. C'est l'approche recommandée pour les projets d'équipe :
Ctrl+Shift+P → CMake: Select Configure Preset → dev-gcc
Ctrl+Shift+P → CMake: Select Build Preset → dev-gcc-debug
L'extension affiche le nom du preset actif dans la barre de statut, ce qui facilite le basculement entre configurations.
Identifiant : ms-vscode.cpptools
Éditeur : Microsoft
L'extension C/C++ de Microsoft est historiquement l'extension de référence pour le C++ dans VS Code. Elle inclut un moteur IntelliSense, un debugger intégré (basé sur GDB ou LLDB) et un formateur de code. Dans notre configuration, nous l'utilisons uniquement pour le debugger — l'analyse de code est assurée par clangd, qui est plus précis.
L'extension C/C++ et l'extension clangd fournissent toutes deux des diagnostics et de l'autocomplétion. Si les deux sont actives simultanément, vous obtiendrez des doublons de diagnostics, des suggestions contradictoires et des ralentissements. La solution est de désactiver le moteur IntelliSense de l'extension Microsoft tout en conservant son debugger :
{
"C_Cpp.intelliSenseEngine": "disabled",
"C_Cpp.autocomplete": "disabled",
"C_Cpp.errorSquiggles": "disabled",
"C_Cpp.formatting": "disabled"
}Avec ces paramètres :
- Désactivé : IntelliSense, autocomplétion, squiggles d'erreur et formatage (tout cela est fourni par clangd).
- Conservé : le debugger (qui n'entre pas en conflit avec clangd).
L'extension clangd peut détecter ce conflit automatiquement si vous avez activé "clangd.detectExtensionConflicts": true — elle affiche alors une notification proposant de désactiver IntelliSense.
La configuration du debugger se fait via un fichier launch.json dans le répertoire .vscode/ du projet. Nous la couvrirons en détail à la section 2.4.2. Voici un aperçu minimal pour vérifier que le debugger fonctionne :
// .vscode/launch.json
{
"version": "0.2.0",
"configurations": [
{
"name": "Debug (GDB)",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceFolder}/build/mon_programme",
"args": [],
"stopAtEntry": false,
"cwd": "${workspaceFolder}",
"environment": [],
"externalConsole": false,
"MIMode": "gdb",
"setupCommands": [
{
"description": "Activer le pretty-printing pour la STL",
"text": "-enable-pretty-printing",
"ignoreFailures": true
}
],
"preLaunchTask": "CMake: build"
}
]
}Le champ "preLaunchTask": "CMake: build" demande à VS Code de compiler le projet avant chaque session de débogage — une sécurité qui évite de déboguer un binaire obsolète.
Le setupCommand -enable-pretty-printing active l'affichage formaté des conteneurs STL dans le debugger. Sans cette option, un std::vector<int> apparaît comme une structure interne complexe ; avec, il s'affiche comme {1, 2, 3, 4}.
Identifiant : twxs.cmake
Éditeur : twxs
Cette extension apporte la coloration syntaxique et une autocomplétion basique pour les fichiers CMakeLists.txt et .cmake. Sans elle, ces fichiers apparaissent en texte brut dans VS Code — ce qui rend leur édition pénible sur un projet complexe.
L'extension reconnaît les commandes CMake (add_executable, target_link_libraries, find_package, etc.), les variables prédéfinies (CMAKE_CXX_STANDARD, PROJECT_SOURCE_DIR, etc.) et les structures de contrôle (if, foreach, function, macro).
Cette extension fonctionne sans configuration. Aucun paramètre à modifier — elle est prête à l'emploi dès l'installation.
Au-delà des quatre extensions essentielles, plusieurs extensions complémentaires améliorent l'expérience C++ dans VS Code.
Identifiant : usernamehw.errorlens
Error Lens affiche les messages de diagnostic (erreurs, warnings, infos) directement à la fin de la ligne concernée, en couleur, sans avoir à survoler le squiggle avec la souris. C'est un gain de productivité notable : les erreurs sautent aux yeux immédiatement.
{
"errorLens.enabledDiagnosticLevels": ["error", "warning"],
"errorLens.delay": 500
}Le delay de 500 ms évite que les diagnostics clignotent pendant la frappe — ils n'apparaissent qu'une demi-seconde après l'arrêt de la saisie.
Si vous n'utilisez pas clangd pour le formatage (ou si vous voulez un contrôle plus fin), l'extension Clang-Format (xaver.clang-format) fournit une intégration directe de clang-format. En pratique, clangd gère déjà le formatage via clang-format en interne, donc cette extension n'est nécessaire que si vous n'utilisez pas clangd.
Identifiant : eamodio.gitlens
Pas spécifique au C++, mais très utile : GitLens enrichit l'interface Git de VS Code avec l'historique inline (qui a modifié chaque ligne et quand), la comparaison de commits, et la navigation dans l'historique d'un fichier. Indispensable pour le travail en équipe.
Identifiant : cschlosser.doxdocgen
Génère automatiquement des squelettes de commentaires Doxygen quand vous tapez /** au-dessus d'une fonction ou d'une classe. Utile pour maintenir une documentation cohérente (voir chapitre 46 — Documentation avec Doxygen).
Voici la configuration complète qui intègre toutes les extensions et paramètres décrits dans cette section. Ce fichier se place soit dans les paramètres utilisateur (~/.config/Code/User/settings.json), soit dans les paramètres du workspace (.vscode/settings.json à la racine du projet).
La version workspace est préférable pour les projets d'équipe, car elle est versionnée avec le code et partagée entre les développeurs.
// .vscode/settings.json — Configuration C++ complète
{
// =====================================================================
// clangd : Analyse de code, autocomplétion, diagnostics
// =====================================================================
"clangd.path": "clangd",
"clangd.arguments": [
"--background-index",
"--clang-tidy",
"--header-insertion=iwyu",
"--completion-style=detailed",
"--function-arg-placeholders",
"--fallback-style=Google",
"--pch-storage=memory",
"-j=4"
],
"clangd.detectExtensionConflicts": true,
"clangd.enableCodeActions": true,
// =====================================================================
// C/C++ Microsoft : Désactiver IntelliSense (conserver le debugger)
// =====================================================================
"C_Cpp.intelliSenseEngine": "disabled",
"C_Cpp.autocomplete": "disabled",
"C_Cpp.errorSquiggles": "disabled",
"C_Cpp.formatting": "disabled",
// =====================================================================
// CMake Tools : Build system
// =====================================================================
"cmake.generator": "Ninja",
"cmake.configureOnOpen": true,
"cmake.configureOnEdit": true,
"cmake.buildDirectory": "${workspaceFolder}/build",
"cmake.configureSettings": {
"CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
"CMAKE_CXX_COMPILER_LAUNCHER": "ccache",
"CMAKE_C_COMPILER_LAUNCHER": "ccache"
},
"cmake.copyCompileCommands": "${workspaceFolder}/compile_commands.json",
"cmake.parallelJobs": 0,
// =====================================================================
// Éditeur : Formatage et comportement
// =====================================================================
"editor.formatOnSave": true,
"editor.defaultFormatter": "llvm-vs-code-extensions.vscode-clangd",
"[cpp]": {
"editor.defaultFormatter": "llvm-vs-code-extensions.vscode-clangd"
},
"[c]": {
"editor.defaultFormatter": "llvm-vs-code-extensions.vscode-clangd"
},
"editor.inlayHints.enabled": "onUnlessPressed",
// =====================================================================
// Fichiers : Associations et exclusions
// =====================================================================
"files.associations": {
"*.h": "cpp",
"*.hpp": "cpp",
"*.tpp": "cpp",
"*.ipp": "cpp"
},
"files.exclude": {
"**/.cache": true,
"**/build": false
},
"search.exclude": {
"**/build": true,
"**/compile_commands.json": true
},
// =====================================================================
// Error Lens (si installé)
// =====================================================================
"errorLens.enabledDiagnosticLevels": ["error", "warning"],
"errorLens.delay": 500
}| Fichier | Portée | Versionné | Cas d'usage |
|---|---|---|---|
~/.config/Code/User/settings.json |
Tous les projets | Non | Préférences personnelles (thème, police, raccourcis) |
.vscode/settings.json |
Un projet | Oui (.vscode/ dans Git) |
Configuration spécifique au projet (compilateur, clangd args) |
La convention recommandée est de placer les paramètres liés au C++ et au projet dans .vscode/settings.json et les préférences visuelles dans les paramètres utilisateur. Ajoutez .vscode/ au .gitignore si les paramètres sont strictement personnels, ou versionnez-le si l'équipe partage la même configuration.
Symptôme : aucune autocomplétion, les #include sont soulignés en rouge, clangd affiche « No compilation database found ».
Cause : le fichier compile_commands.json est absent ou introuvable. clangd le cherche en remontant l'arborescence depuis le fichier ouvert.
Solution :
# Vérifier que le fichier existe
ls build/compile_commands.json
# S'il n'existe pas, reconfigurer CMake
cmake -B build -G Ninja -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
# Créer le lien (ou configurer cmake.copyCompileCommands)
ln -sf build/compile_commands.json compile_commands.jsonSymptôme : chaque erreur ou warning apparaît deux fois dans le panneau « Problems ».
Cause : IntelliSense (extension C/C++) et clangd produisent chacun leurs diagnostics.
Solution : désactiver IntelliSense comme décrit ci-dessus :
{ "C_Cpp.intelliSenseEngine": "disabled" }Symptôme : le formatage automatique à la sauvegarde produit un style différent de celui attendu par l'équipe.
Cause : clangd utilise son style de fallback (Google, LLVM, etc.) en l'absence d'un fichier .clang-format.
Solution : créez un fichier .clang-format à la racine du projet avec votre style. Exemple pour un style proche de Google avec quelques ajustements :
# .clang-format
BasedOnStyle: Google
IndentWidth: 4
ColumnLimit: 100
AllowShortFunctionsOnASingleLine: Empty clangd détecte automatiquement ce fichier et l'utilise pour le formatage. Nous reviendrons sur clang-format en détail à la section 32.3.
Symptôme : l'autocomplétion et la navigation mettent plusieurs minutes à devenir opérationnelles à l'ouverture d'un gros projet.
Cause : clangd indexe tout le projet en arrière-plan. La première indexation est nécessairement lente ; les suivantes sont quasi instantanées grâce au cache d'index (.cache/clangd/).
Solutions :
- S'assurer que
--background-indexest activé (le cache est sauvegardé sur disque). - Ajuster le nombre de threads d'indexation (
-j=N) selon votre machine. - Ne pas exclure
.cache/du workspace, sinon l'index est recalculé à chaque ouverture.
Symptôme : la barre de statut affiche « No Kit Selected » ou ne propose pas le compilateur voulu.
Solution : exécutez la commande de scan des kits :
Ctrl+Shift+P → CMake: Scan for Kits
CMake Tools parcourt le PATH et les emplacements standards pour détecter les compilateurs disponibles. Si votre compilateur est installé dans un emplacement non standard, ajoutez-le manuellement dans .vscode/cmake-kits.json :
[
{
"name": "GCC 15",
"compilers": {
"C": "/usr/bin/gcc-15",
"CXX": "/usr/bin/g++-15"
}
},
{
"name": "Clang 20",
"compilers": {
"C": "/usr/bin/clang-20",
"CXX": "/usr/bin/clang++-20"
}
}
]💡 Si votre projet utilise des CMake Presets (recommandé), les kits deviennent inutiles : les presets spécifient directement le compilateur. CMake Tools bascule automatiquement en mode presets quand un
CMakePresets.jsonest détecté.
- Quatre extensions essentielles : clangd (analyse de code), CMake Tools (build system), C/C++ Microsoft (debugger), CMake Language Support (coloration CMake).
- clangd est le cœur de l'expérience : c'est lui qui fournit l'autocomplétion sémantique, les diagnostics et la navigation. Sa qualité dépend du
compile_commands.json— assurez-vous qu'il est généré et accessible. - Désactivez IntelliSense Microsoft (
"C_Cpp.intelliSenseEngine": "disabled") pour éviter les doublons de diagnostics et les conflits avec clangd. Gardez l'extension C/C++ uniquement pour le debugger. cmake.copyCompileCommandsautomatise la copie ducompile_commands.jsonà la racine du projet — plus fiable qu'un lien symbolique manuel.- Le fichier
.vscode/settings.jsonversionné avec le projet garantit que tous les membres de l'équipe ont la même configuration de l'éditeur. - Error Lens est un ajout simple mais très efficace : les erreurs s'affichent directement à la fin de la ligne fautive.