Comme toutes les normes, celles du langage C ne sont pas gratuites. Néanmoins, on trouve sur l'Internet en libre accès les brouillons (drafts), par exemple ici G ou encore là C (c'est la page officielle du groupe de travail WG14). Ces textes conviennent parfaitement comme références de normalisation, même pour un codeur expérimenté.

Également, il faut avoir conscience que, comme toutes norme de langage de programmation, celle du langage C est particulièrement complexe. Elle a vocation à servir de texte de référence pour l'élaboration des compilateurs. Ce n'est pas un document pédagogique (c'est d'ailleurs écrit noir en première page) et, pour un codeur, il serait donc très inefficace de baser dessus son apprentissage. En revanche, il est souvent judicieux de la consulter pour éclaircir un détail technique précis.

La liste ci‑dessous donne quelques exemples emblématiques – mais elle ne constitue qu'un tout petit aperçu – des logiciels codés en langage C.

• GIMP W, logiciel libre d'édition et de manipulation d'images ;
• GNU/Linux W, adaptation du système Unix pour ordinateurs personnels ;
• pcap/libcap W, bibliothèque de fonctions / API pour la capture et l'analyse de paquets réseaux, notamment utilisée par Wireshark ;
• Radare2 W, outil de retro‑ingénierie pour l'analyse des fichiers binaires ;
• BIND W, serveur DNS ;
• Zend Engine W, moteur d'interprétation du langage php ;
• NGINX W, logiciel de serveur web ;
• Apache W, logiciel de serveur web ;
• SQLite W, moteur de base de données embarqué ;
• Postfix W, serveur du protocole de messagerie SMTP ;
• Dovecot W, serveur du protocole de messagerie IMAP/POP3 ;
• Cyrus W, serveur du protocole de messagerie IMAP ;
• OpenVPN W, logiciel de VPN ;
• Asterisk W, logiciel de serveur de téléphonie (IPBX) ;
• Jami W, logiciel de téléphonie (soft phone) ;
• Libopus W, codec des signaux audio ;
• Mosquitto , implémentation du protocole de communication MQTT ;
• Subversion W, utilitaire de gestion de versions logicielles.

Toutefois, soulignons dès à présent que de nombreux éléments de langage du  C (notamment les pointeurs) sont déconseillées en C++. En effet, ce dernier introduit à la place de nouveaux concepts dans une perspective de permettre une meilleure sécurité des programmes codés.

De surcroît, le langage C++ apporte de nombreuses fonctionnalités de haut niveau (cf. infra) qu'il est dommage d'ignorer en recourant aux techniques moins évoluées, plus fastidieuses – et donc, là encore, moins sûres – du langage C. C'est pourquoi en règle générale, un programme qui exploite pleinement les possibilités du C++ est potentiellement incompréhensible pour un codeur qui ne connaîtrait que le C.

La liste ci‑dessous donne quelques exemples emblématiques des logiciels principalement ou totalement codés en langage C++.

• Microsoft Office W (suite bureautique qu'on ne présente plus), ainsi que d'autres logiciels phares de la firme de Redmond, comme Outlook ;
• LibreOffice W, suite bureautique libre et open‑source ;
• Adobe Illustrator W, logiciel de dessin vectoriel ;
• Adobe Photoshop W, logiciel de traitement d'images matricielles ;
• Catia W, logiciel CAO (conception assistée par ordinateur) ;
• Scilab W, logiciel de simulation et calcul numérique ;
• Sublime Text W, éditeur de code ;
• Code::Blocks W, environnement intégré de développement ;
• Wireshark W, logiciel de capture et d'analyse de paquets réseaux ;
• FileZilla W, logiciel client FTP (transferts de fichiers entre hôtes distants) ;
• Blink W, moteur de rendu du navigateur Chrome ;
• WebKit W, moteur de rendu du navigateur Safari ;
• Gecko W, moteur de rendu du navigateur Firefox ;
• 7-Zip W, utilitaire de compression de données ;
• 3CX W, logiciel de téléphonie VoIP.

Mais encore une fois, insistons sur le fait qu'il ne s'agit là que d'un tout petit aperçu qui passe sous silence les innombrables applications industrielles du langage C++ inconnues du grand public.

Les composants logiciels des chaînes de compilation seront détaillés au chapitre C4‑IV .

En règle générale, toute chaîne de compilation apporte des extensions aux langages qu'elle prend en charge, qui viennent en complement des spécifications de la norme, pour faciliter le codage des programmes. Dans le cas des chaînes GCC, on parle d'extensions GNU. On peut en trouver la liste exhaustive pour les langages C/C++ sur cette page de référence C.

Cependant, l'usage des extensions présente l'inconvénient principal de rendre les programmes ainsi codé moins portables. En effet, ils ne peuvent a priori pas être compilés avec une autre chaîne de compilation.

Enfin, dans les archives d'installation, à une chaîne de compilation GCC est le plus souvent associée un débogueur GDB W. C'est un outil logiciel du projet GNU (donc, ouvert et gratuit) qui permet l'exécution pas à pas d'un programme – à condition que son code source soit disponible.

À partir d'un certain niveau de complexité des programmes développés, un débogueur est indispensable pour la mise au point. Il facilite grandement la recherche des causes de dysfonctionnement.

Gestion des avertissements et erreurs

gcc -Wall -Wextra -Werror …

Enfin, pour une détection plus poussée des erreurs potentielles, les commandes gcc et g++ disposent de l'option -fanalyser qui met en œuvre une analyse statique approfondie du programme (cf. un exemple d'utilité au chap. C5‑I ). Sans aller jusqu'à tester son exécution, cette option explore de nombreux scénarios possibles, mais bien sûr au prix d'un surcoût en terme de temps d'exécution d'autant plus lourd que le programme est complexe.

De plus, Sublime Text n'est pas apprécié pour rien. Il possède de nombreux atouts, parmi lesquels on peut citer :

• sa légèreté, le lancement étant quasi‑instantané sur un poste de travail, même avec une configuration matérielle peu performante ;
• son interface minimale qui maximise l'espace de l'écran pour l'édition du code ;
• la sauvegarde automatique de la saisie (à tout moment, le logiciel garde en mémoire son état intégral et, même en cas de fermeture inopinée, même lors d'un arrêt brutal du système, le contenu des fichiers est restitué tel quel lorsqu'il est à nouveau relancé) ;
• ses fonctionnalités ergonomiques pour le développement (multi‑fenêtrage pour visualiser différentes parties d'un fichier ou plusieurs fichiers différents, visualisation miniature du contenu des fichiers, coloration syntaxique spécifique au langage, auto‑complétion, macro‑commandes, raccourcis clavier, etc.) ;
• le paramétrage des préférences permet de configurer finement l'interface utilisateur – notamment la coloration syntaxique W – et ce de façon portable (cf. chap. C1‑I ) ;
• un grand nombre d'extensions (plugins) développées par la communauté des utilisateurs qui permettent d'augmenter considérablement les fonctionnalités au gré des besoins spécifiques de chaque codeur.

Accès aux paramètres de réglage

Ainsi, on accède aux fichiers de réglages généraux via le menu Preferences/Settings. Automatiquement, une nouvelle fenêtre de l'application Sublime Text s'ouvre (cf. la capture d'écran ci‑après) avec deux fichiers homonymes nommés Preferences.sublime-settings, respectivement affichés dans deux onglets :

• À gauche, on a le fichier de réglages par défaut, à ne pas modifier (il est placé dans le répertoire d'installation de l'application, en principe accessible seulement avec des droits d'administration). Volumineux, il est agrémenté de longs commentaires pour expliquer toutes les possibilités de réglage.
• À droite, on le fichier de réglages utilisateur, placé dans répertoire de préférences de l'utilisateur, dans lequel ce dernier peut coder, pour chaque paramètre du fichier par défaut, des valeurs différentes de celle du fichier par défaut en s'inspirant de sa syntaxe et des commentaires assortis.

Quant au paramétrage de la coloration syntaxique pour tel ou tel langage, il sera abordé ultérieurement (cf. chap. C2‑X ).

L'environnement de développement intégré Visual Studio Code

Visual Studio Code W est un éditeur de code suffisamment extensible pour constituer un véritable environnement intégré de développement, à la fois multi‑plateformes (Linux, Windows, MacOS) et multi‑langages.

Développé par Microsoft, c'est un logiciel libre et open‑source, distribué sous licence GNU GPL version 3 (cf. supra ). Sa première version date de 2015.

Caractéristiques remarquables

Outre sa gratuité et sa fiabilité, VS Code réunit de nombreuses qualités qui en font, depuis quelques années déjà, l'environnement de développement le plus populaire, tous publics confondus (cf. le Stack Overflow Developer Survey ).

• Fortement paramétrable, il peut offrir au codeur une interface « sur mesure » parfaitement adaptée à tel ou tel contexte de développement (web, embarqué, etc.). En particulier, la coloration syntaxique peut faire l'objet de règles très spécifiques selon le langage de programmation utilisé et les préférences du codeur, pour améliorer au maximum la lisibilité du code.
• Extrêmement modulaire, il est constitué d'un « noyau » assez réduit (donc rapide à charger) auquel on peut greffer de très nombreuses extensions que chaque codeur est libre de choisir en fonction de ses besoins (pour tel ou tel langage, framework, etc.).

À lui seul, le noyau intègre certaines fonctionnalités très appréciées par les codeurs professionnels, notamment :

• des outils puissant de remaniement du code source W (en anglais, refactoring), c'est‑à‑dire de remplacement d'éléments de code dans la totalité des fichiers source d'un projet ;
• l'intégration de Git, l'outil de gestion décentralisée de versions logicielles qui est incontournable pour le développement logiciel en équipes (cf. chap. C1‑I ) ;
• l'auto‑complétion intelligence – dénommée IntelliSense  – pour les langages de la programmation web (HTML/CSS/JS) ;

Quant aux extensions, elles sont installables via un marché – en anglais, Marketplace  – comme pour beaucoup de logiciels, sachant que la plupart sont gratuites.

Ces extensions permettent de prendre en charge de les langages les plus usuels, notamment C, C++, C#, Java, Python, PHP, Go… En règle générale, une seule extension ne suffit pas : chacune joue un rôle bien spécifique pour intégrer dans VS Code telle ou telle fonctionnalité attendue pour un langage donné : auto‑complétion intelligente, compilation, débogage, etc.

Installation

L'installation de VS Code ne pose pas de difficulté, mais nécessite néanmoins d'effectuer quelques choix particuliers :

Pour un poste de travail à système Linux, il est déconseillé jusqu'à nouvel ordre d'installer le paquet flathub disponible via certaines logithèques (dont celle de Linux Mint), car il s'agit d'une version non officielle qui s'exécute dans un conteneur et peut poser des problèmes ultérieurs dans le cadre d'une utilisation experte. Il est recommandé de télécharger le paquet adapté directement sur le site de VS Code  – typiquement, le paquet .deb pour les distributions Debian, Ubuntu, Mint.
Ensuite, il suffit d'exécuter ce paquet d'installation avec l'utilitaire adapté (premier choix lorsque l'on clique dessus).
Sous Linux Mint, on peut alors :
• retrouver le logiciel listé dans le menu Démarrer et ajouter son raccourci au tableau de bord (panneau).
• vérifier la version de VS Code qui est installée via la commande :

		
code -v
		


Pour un poste de travail à système Windows, sur la page de téléchargement , ne pas cliquer directement sur le bouton principal Download (qui oriente vers une version mono‑utilisateur), mais choisir un installateur système (pour un usage multi‑utilisateurs) et une version 64 bits, donc typiquement un fichier exécutable dont le nom commence par VSCodeSetup-x64 suivi du numéro de version.
Ensuite, la procédure est usuelle (acceptation des termes de la licence, etc.) et le logiciel s'installe par défaut dans le répertoire :
C:\Program Files\Microsoft VS Code

Prise en main

De plus, comme Sublime Text , VS Code dispose d'une palette générale de commandes, activée par défaut par le raccourcis CtrlshiftP ou la touche F1. Fonctionnant en mode texte avec auto‑complétion dynamique, elle permet de sélectionner n'importe quelle commande existante dès la saisie des premières lettres de son appellation.

Pour plus de détails sur les diverses fonctionnalités de VS Code, on pourra consulter ce guide d'initiation très complet rédigé par Microsoft .

Accès aux paramètres de réglage

La gestion des paramètres de VS Code diffère de celle de Sublime Text. On y accède via fenêtre d'interface (cf. la capture d'écran ci‑dessous) ouverte via le menu File/Preferences/Settings (raccourci Ctrl,).

• Pour trouver facilement un paramètre (car il y en a énormément !), cette fenêtre intègre :
• en haut, une barre de recherche avec auto‑complétion ;
• à gauche, un panneau de navigation avec les différentes rubriques de classement des paramètres.
• Chaque paramètre est présenté avec son appellation, une brève description (avec éventuellement des liens hypertextes) et un champ pour choisir sa valeur.

À tout moment, il est possible de réinitialiser un paramètre à sa valeur par défaut par la commande Reset Setting accessible par un menu contextuel qui s'affiche en cliquant sur un bouton caché ⚙ situé à gauche du nom du paramètre (cf. la capture d'écran ci‑contre).

De plus, il est possible d'éditer dans un fichier de préférences nommé settings.json (cf. supra ) tous les paramètres modifiés par l'utilisateur en cliquant sur le bouton de raccourci en haut à droite de la fenêtre (cf. la capture d'écran ci‑contre).

Si, dans la fenêtre d'interface, on modifie seulement le paramètre Tab Size (cf. supra ) en lui donnant la valeur 2, on obtient le fichier de préférences settings.json représenté sur la capture d'écran ci‑contre.

Comme pour Sublime Text, ce fichier de réglages utilisateur est portable. Il est placé dans un répertoire dont le chemin d'accès dépend du système d'exploitation.

• Sous Linux :
  /home/username/.config/Code/User
• Sous Windows :
  C:\Users\username\AppData\Roaming\Code\User

Mais contrairement à Sublime Text, avec l'application VS Code, il n'est pas possible de visualiser les réglages par défaut sous la forme d'un fichier au format JSON.

Extension pour la prise en charge de C/C++

En ce qui concerne l'extension à installer, il est vivement recommandé de choisir celle dénommée simplement C/C++ qui est développée par Microsoft (cf. son icône ci‑contre). On la trouve en cliquant dans sur le bouton de raccourci vers les extensions (cf. supra ou taper CtrlShiftX) qui donne un accès direct au marché des extensions (Marketplace). Dans le panneau latéral gauche ainsi ouvert, il suffit de saisir « C » dans la barre de recherche. Elle apparaît alors en premier choix, il n'y a plus qu'à la sélectionner et cliquer sur le bouton bleu Install.

Un fois l'installation terminée, dans sa fenêtre d'accueil, il est proposé de choisir d'installer ou d'indiquer l'accès à la chaîne de compilation qui doit être utilisée par défaut pour les langages C/C++. Dans le cas où l'installation est déjà faite, le chemin d'accès aux exécutables de la chaîne de compilation dépend bien entendu du système d'exploitation ; au regard des choix précédents – installation de GCC, cf. supra  – on saisit donc :

• /usr/bin/gcc sous Linux ;
• C:\Program Files\mingw64\bin\gcc.exe sous Windows.

En examinant le fichier des préférences utilisateur settings.json, on trouve alors une ligne de code de la forme :
"C_Cpp.default.compilerPath": path
où path est le chemin détaillé ci‑dessus selon le système d'exploitation.

Remarque : au format JSON, dans le codage des chemins du système de fichiers de Windows, toute occurrence du séparateur « \ » doit être doublée, c'est‑à‑dire saisie \\ pour former ce qu'on appelle une séquence d'échappement (cf. chap. C2‑VII ).

Avec l'extension C/C++ installée et paramétrée, la compilation, l'exécution et même le débogage d'un programme sont autant de tâches pouvant être effectuées au sein de VS Code, qui constitue alors un véritable IDE. La procédure décrite ci‑dessous en donne un exemple minimal d'utilisation.

• Après avoir créé un répertoire de projet, on peut l'ouvrir via le menu File/Open Folder. Cette commande affiche automatiquement la fenêtre d'accueil dans laquelle on trouve des liens de raccourcis utiles, notamment New File….
• Lorsqu'on crée un nouveau fichier source nommé hello.c, l'application VS Code reconnaît son extension et l'ouvre automatiquement avec la coloration syntaxique et l'auto‑complétion appropriées au langage C. On peut s'en rendre compte en saisissant le code ci‑dessous (à enregistrer après saisie) :

#include <stdio.h>

int main(void)
{
  printf("Hello, World!\n");
  return 0;
}


De plus, l'application VS Code affiche en haut à droite de la fenêtre d'édition un bouton ▷ (Run) associé à un menu déroulant. Ce menu permet de sélectionner la tâche de compilation et/ou d'exécution et de débogage du programme qui est lancée lorsqu'on clique sur le bouton.
Via ce bouton, la première fois que la commande Run C/C++ File est lancée, elle renvoie automatiquement à la palette de commandes (cf. supra ) dans laquelle il suffit de cliquer sur le premier choix, spécifique à l'extension C/C++ (l'intitulé de la commande dépend du système) :
C/C++: gcc build and debug active file
Cette commande lance une procédure complexe nécessitant quelques secondes d'exécution – mais heureusement transparente pour l'utilisateur. Elle comprend les étapes suivantes :
• La création dans le répertoire de projet d'un sous‑répertoire .vscode ;
et dans ce répertoire, la création d'un fichier de tâches tasks.json codant les paramètres de la compilation.
• La compilation du programme avec la création du fichier exécutable correspondant au fichier source, nommé hello sous Linux, hello.exe sous Windows ;
on en retrouve le compte‑rendu (log) dans l'onglet TERMINAL du cadre bas de l'application en sélectionnant la tâche C/C++: gcc build active file dans le panneau latéral droit.
• L'exécution du programme dans le terminal de commandes en lignes intégré à VS Code ;
on en retrouve le compte‑rendu (log) dans l'onglet TERMINAL de la fenêtre basse en sélectionnant la tâche cppdbg: hello dans le panneau latéral droit (la chaîne de caractères Hello, World! a été affichée conformément au code source).

sachant que l'exécution est effectuée par le biais du débogueur associé à la chaîne de compilation sélectionnée. On peut le vérifier en observant l'icône d'insecte (bug) associé au terminal d'exécution ; et cela explique, durant l'exécution, les sorties de texte dans l'onglet de la console de débogage, que nous ne détaillerons pas pour le moment.
• À partir de là, si l'on lance à nouveau la commande Run C/C++ File pour le fichier source actif, on constate qu'elle est plus rapide : elle ne passe plus par la palette de commande mais enchaîne directement la compilation et l'exécution du programme en mode débogage.
• Enfin, si l'on souhaite déclencher seulement la compilation du programme sans pour autant l'exécuter, il suffit de taper le raccourci CtrlShiftB (pour build).

À travers cet exemple d'utilisation le plus réduit possible, on peut donc mesurer que l'éditeur VS Code est difficile à prendre en main par un débutant. On va voir ci‑après que les possibilités de paramétrages sont encore plus nombreuses et ramifiées qu'on pourrait l'imaginer et qu'il importe de ne pas confondre les différentes configurations qui s'y rapportent.

Paramétrage de la chaîne de compilation

Dans le fichier tasks.json, la tâche de génération du code exécutable créée par défaut par l'extension C/C++ présente le code suivant :

    {
      "type": "cppbuild",
      "label": "C/C++: gcc générer le fichier actif",
      "command": "/usr/bin/gcc",
      "args": [
        "-fdiagnostics-color=always",
        "-g",
        "${file}",
        "-o",
        "${fileDirname}/${fileBasenameNoExtension}"
      ],
      "options": {
        "cwd": "${fileDirname}"
      },
      "problemMatcher": [
        "$gcc"
      ],
      "group": {
        "kind": "build",
        "isDefault": true
      },
      "detail": "Tâche générée par le débogueur."
    }

à propos duquel on peut apporter les précisions suivantes :

• À la ligne nº 4, la valeur cppbuid de l'attribut type est spécifique à l'extension C/C++. De plus, elle est définie comme la tâche par défaut du groupe de tâches du genre build (cf. les lignes nº 21 & 22).
Ces propriétés sont indispensables pour que cette tâche soit reconnue comme celle devant être exécutée lorsqu'on clique sur le bouton ▷.
• À la ligne nº 5, la valeur de l'attribut label est le nom de la tâche ; c'est cette valeur qui permet d'identifier la tâche dans d'autres codages de configuration, par exemple pour définir un raccourci, imposer une contrainte d'antériorité, etc.
• À la ligne nº 6, la valeur de l'attribut command est le chemin vers l'exécutable qui pilote la chaîne de compilation. Pour une compilation en C++, il suffit donc de remplacer gcc par g++.
• À la ligne nº 6, la valeur de l'attribut args est la liste des arguments de la commande de compilation. Pour ajuster le niveau d'avertissement conformément aux usages recommandés en apprentissage de la programmation (cf. supra ), il suffit donc d'ajouter les items suivants :

        "-Wall",
        "-Wextra",
        "-Werror",

en respectant la règle « un élément, une ligne », qu'il s'agisse d'une option ou d'un argument associé à une option.
• À la ligne nº 14, la valeur de l'attribut options définit les options de la tâche (pas de la commande). Ici est défini le répertoire courant de travail (current working directory) dans lequel la commande est exécutée – sinon, c'est le répertoire racine qui est choisi par défaut.

Configuration d'autres tâches

En particulier, il est utile pouvoir disposer d'une tâche de test du programme, c'est‑à‑dire d'exécution seule, sans regénération du code exécutable. Une telle tâche peut‑être codée comme ci‑dessous :

    {
      "type": "shell",
      "label": "Run C/C++ File",
      "command": "${fileDirname}/${fileBasenameNoExtension}",
      "options": {
        "cwd": "${fileDirname}"
      },
      "presentation": {
        "reveal": "always",
        "panel": "shared"
      },
      "group": {
        "kind": "test",
        "isDefault": true
      },
      "detail": "Specifically coded in tasks.json"
    }

Dans ce code :

• À la ligne nº 30, la tâche est définie de type shell, non spécifique à une extension, ce qui signifie qu'elle se déroule dans un terminal de commandes en ligne.
De plus, les lignes nº 40 à 43 précisent qu'elle est la tâche par défaut de celles du genre test, c'est‑à‑dire d'exécution de code.
• Aux lignes nº 36 à 39, la tâche est configurée de sorte que son processus d'exécution soit systématiquement visible et se déroule dans un onglet partagé, c'est‑à‑dire commun avec d'autres tâches.

On peut également coder une tâche qui permet d'enchaîner la génération et l'exécution, comme ci‑dessous :

    {
      "type": "shell",
      "label": "C Compile and Run program",
      "command": "${fileDirname}/${fileBasenameNoExtension}",
      "options": {
        "cwd": "${fileDirname}"
      },
      "dependsOn": [
        "C/C++: gcc générer le fichier actif"
      ],
      "dependsOrder": "sequence",
      "presentation": {
        "reveal": "always",
        "panel": "shared"
      },
      "group": {
        "kind": "test",
        "isDefault": false
      },
      "detail": "Specifically coded in tasks.json"
    }

Par rapport au code de la tâche Run C/C++ File donné supra, on peut observer deux différences :

• Les lignes nº 53 à 56 imposent la contrainte d'antériorité de la tâche de génération, qui sera donc systématiquement appelée avant ;
• Les lignes nº 61 à 64 précisent que la tâche est du genre test mais n'est pas celle par défaut.

Raccourcis claviers

Sous VS Code, on accède aux raccourcis claviers via le menu :
File/Preferences/Keyboard Shortcuts
ou encore via le bouton ⚙ de paramétrage (manage) situé en bas à gauche de la fenêtre de l'application.

Dans l'interface utilisateurs, ils se présentent sous la forme d'un tableau à quatre colonnes qui recense toutes les commandes de l'application, comme le montre la capture d'écran (partielle) ci‑dessous.

sachant que seule une petite partie de ces commandes font par défaut l'objet d'un raccourci.

Le nombre de commandes étant potentiellement très grands, on dispose d'une barre de recherche qui opère par comparaison du motif saisi (sous‑chaîne de caractères) avec tous les éléments de texte contenus dans le tableau (les motifs trouvés apparaissent instantanément en couleur). On peut donc faire une recherche par nom, par commande, par séquence de touches…

Après avoir sélectionné une entrée du tableau (ligne), on active son édition en cliquant sur le bouton (stylo) qui s'affiche à tout gauche de la ligne. On peut ainsi attribuer ou modifier le raccourci clavier qui est affecté à la commande, en précisant éventuellement les circonstances dans lesquelles le raccourci est utilisable (colonne When).

Pour une utilisation plus experte, on peut aussi éditer les raccourcis dans un fichier utilisateur au format JSON nommé keybindings.json. On peut y accéder soit en cliquant sur le bouton en haut à droite dans la barre d'onglet de l'application, soit via la palette de commande en saisissant :
Preferences: Open Keyboard Shortcuts (JSON)
sachant que le fichier lui‑même est placé dans un répertoire utilisateur. Sous Linux, il est typiquement accessible via le chemin :
home/user/.config/Code/User

Par défaut, ce fichier est vide, sa fonction étant de mémoriser toutes les modifications apportées par l'utilisateur par rapport aux raccourcis définis par l'application et ses extensions.

Dans le fichier keybindings.json, chaque raccourci est potentiellement codé par une règle à quatre attributs, les deux premiers étant obligatoires :

• key, dont la valeur définit la séquence de touches ;
• command, dont la valeur définit la commande déclenchée ;
sachant que lorsque cette commande est précédée du signe -, la règle code la suppression d'un raccourci préalablement défini.
• arg, dont la valeur définit les arguments éventuels de la commande ;
• when, dont la valeur définit les circonstances éventuelles dans lesquels le raccourci peut être utilisé.

Par rapport au tableau de l'interface utilisateur, l'attribut arg apporte une puissance d'expression supplémentaire. Il permet notamment de cibler n'importe quelle tâche codée dans le fichier tasks.json.

  {
    "key": "alt+t",
    "command": "openInIntegratedTerminal"
  },
  {
    "key": "ctrl+shift+t",
    "command": "-workbench.action.reopenClosedEditor"
  },
  {
    "key": "ctrl+shift+alt+t",
    "command": "workbench.action.reopenClosedEditor"
  },
  {
    "key": "ctrl+shift+t",
    "command": "workbench.action.tasks.test",
    "when": "editorLangId == 'c' || editorLangId == 'cpp'"
  },
  {
    "key": "ctrl+shift+alt+b",
    "command": "workbench.action.tasks.runTask",
    "args": "C Compile and Run program",
    "when": "editorLangId == 'c' || editorLangId == 'cpp'"
  }

Pour plus de détails sur les raccourcis, on pourra consulter cette page de référence de l'application VS Code .

Configuration de IntelliSense

Comme pour les tâches de compilation avec le fichier tasks.json (cf. supra ), pour un même projet, il est possible de définir plusieurs configurations différentes d'IntelliSense via le fichier c_cpp_properties.json.

• On peut paramétrer une configuration en codant notamment le chemin vers compilateur utilisé, la norme du langage à appliquer, l'architecture de la machine‑cible, etc. (il est commode de recourir à la fenêtre d'interface pour voir toutes les possibilités).
• Pour sélectionner une configuration, il suffit de cliquer sur le nom de la configuration active qui est affiché dans la barre de notifications. La palette de commande propose alors la liste de toutes les configurations définies pour le projet.

Configuration du débogage

On a vu supra  que lorsqu'on clique sur le bouton ▷ pour un fichier source actif déjà compilé, l'application VS Code lance successivement deux processus :

• la compilation du code source conformément aux indications codées dans le fichier tasks.json ;
• l'exécution du programme par le biais du débogueur W.

Comme pour la fonctionnalité IntelliSense, pour un même projet, il est possible de définir plusieurs configurations différentes via le fichier launch.json. Et dans une configuration, on peut notamment changer le débogueur utilisé, définir des points d'arrêts et d'autres éléments relatifs au débogage W.

Notion de workspace

On a vu supra  que pour le codage des programmes simples (ce qui est le cas des exercices et travaux pratiques proposés dans ce module de formation), il est commode de placer directement dans un répertoire de projet tous les fichiers (source et exécutable).

Toutefois, pour des programmes plus complexes, il peut être nécessaire de répartir les fichiers dans divers répertoires qui eux‑mêmes ne sont pas placés directement dans un répertoire commun.

Pour sélectionner une norme particulière, avec la commande gcc, on emploie l'option -std= suivie d'une sous‑option de la forme gnu⦁⦁ ou  c⦁⦁ (attention, en minuscules) selon que l'on souhaite respectivement disposer ou non des extensions GNU (cf. supra ).

Quant aux deux symboles ⦁⦁, ils codent le millésime de révision de la norme du langage C. Attention, ces deux symboles ne peuvent prendre que les valeurs 89 ou 90 (équivalentes), 99, 11, 17 ou 18 (équivalentes) et 2x (version expérimentale pour la norme C23 – laquelle n'est vraiment prise en charge qu'à partir de la version gcc-14 de la chaîne de compilation).

Il en va de même pour le langage C++ avec la commande g++ qui admet des sous‑options de la forme c++⦁⦁ avec comme valeurs possibles 98, 03, 11, 14, 17, 20 et 23 (le millésime C++26 n'est pas encore pris en charge).

Avec l'IDE VS Code, il est donc très simple de choisir tel ou tel millésime de la norme du langage adopté par le compilateur pour d'un programme donné. Il suffit de coder une ligne d'option comme celles de l'exemple ci‑dessus dans le paramètre args des tâches de compilation et de génération définies dans le fichier tasks.json (cf. supra ).

De plus, pour un fonctionnement optimal d'IntelliSense, il est recommandé de coder la même valeur de millésime à l'argument cStandard dans le fichier c_cpp_properties.json (cf. supra ).

En revanche, avec la plupart des environnements de programmation en ligne, il n'est pas toujours facile de sélectionner telle ou tel millésime de la norme du langage.

Par exemple, sur OnlineGDB, on ne peut pas directement choisir la norme pour le langage C – alors que pour le C++, on a le choix entre les normes C++11 (choix par défaut), C++14, C++17 et C++23.

En revanche, il est toujours possible d'ajouter à la ligne de commande une option de la forme -std=c⦁⦁ via le bouton Extra Compiler Flafs dans le menu des paramètres ⚙ (cf. supra ).

Enfin, lors de l'exécution d'un programme, quel que soit l'environnement utilisé, il reste possible d'avoir une indication du millésime de la norme employée par la chaîne de compilation. Il suffit pour cela de coder dans le fichier source du programme une instruction qui affiche la valeur d'une variable d'environnement spécifique au langage :

• en langage C, c'est la variable __STDC_VERSION__ ;
• en langage C++, c'est la variable __cplusplus.

Ces variables sont l'une et l'autre de type long int (cf. chap. C3‑II). Elles expriment dans le sens de lecture (de gauche à droite) une indication de l'année et le numéro du mois de la version de la norme. Toutefois, dans certains cas, cette indication peut prêter à confusion.

Les options « pedantic » de GCC

• La plus connue est l'option d'avertissement -Wpedantic, dont l'ancienne forme -pedantic est encore valide. Lorsqu'elle est invoquée, le compilateur émet un avertissement à chaque fois que le programme ne respecte pas strictement la norme spécifiée ou sélectionnée par défaut par la commande de compilation, même si ce programme est quand même compilable et correctement exécutable grâce aux extensions qu'il exploite.
• Il y a aussi l'option -pedantic-errors qui convertit les avertissements de type « pedantic » en erreur de compilation, et ce faisant bloque la production du code exécutable – de la même manière que le fait l'option -Werror pour tout avertissement en général (cf. supra ).
Donc, cette option ne nécessite pas l'invocation de l'option -Wpedantic pour être opérationnelle, mais elle est redondante avec l'invocation de -Werror.

int main(void)
{
  float square(float x) {return x * x;} // nested function
  return square(2);
}