Synthèse et défis : premiers pas

Résumé

Cette leçon clôt la première unité du cours, consacrée aux premiers pas dans la programmation en C++. Elle reconstruit la chaîne de concepts qui va du problème spécifié à l’erreur classée selon son moment, en passant par l’algorithme, le code source, la compilation et l’édition de liens, l’exécutable et la communication du programme avec l’extérieur ; elle sépare ce qui, dans tout cela, vaut dans tout langage de ce qui est propre à C++ ; elle rassemble le comportement indéfini que l’unité a montré et la règle du cours qui en découle, compiler toujours avec les avertissements et, pendant le développement, avec les détecteurs ; elle reprend dans son évaluation de sortie les compétences de l’évaluation d’entrée ; et elle se termine par six défis qui combinent l’unité entière : le rendu de monnaie avec le moins de pièces, un tableau aligné sans boucles, un programme à cinq défauts de cinq natures, une expérience sur le tampon de sortie, une date au format fixe et l’explication du compilateur à qui ne connaît qu’un langage interprété.

Objectifs d’apprentissage

Parcourir sans aide le chemin de l’énoncé au programme exécuté : spécifier, écrire l’algorithme, le suivre à la main, l’écrire en C++, le compiler avec les options du cours, l’exécuter et vérifier son résultat.
Expliquer quel outil agit à chaque étape de ce chemin (éditeur, préprocesseur, compilateur, éditeur de liens, détecteurs) et ce que chacun reçoit et livre.
Reconnaître la nature d’une erreur (de compilation, d’édition de liens, d’exécution ou de logique) à sa manifestation, et corriger plusieurs erreurs dans l’ordre où elles se révèlent.
Expliquer à l’aide d’un exemple ce qu’est le comportement indéfini et pourquoi le cours compile avec avertissements et détecteurs.
Séparer, dans ce qui a été appris dans l’unité, ce qui vaut dans tout langage de ce qui est propre à C++.

L’acquis de l’unité

L’unité s’est proposé de mener quelqu’un qui n’a jamais programmé d’un problème énoncé en langage courant jusqu’à un programme qui compile, s’exécute, lit des données et écrit des résultats, en sachant ce que chaque outil a fait en chemin. Elle y est parvenue en s’appuyant seulement sur ce que l’introduction a déclaré tenu pour acquis : l’arithmétique scolaire, l’habitude de suivre des instructions écrites et le maniement des fichiers et des dossiers.

Du problème à l’algorithme

La leçon Du problème à l’algorithme a établi qu’un problème est fixé par sa spécification, un contrat qui promet la postcondition à toute entrée qui satisfait la précondition, et rien en dehors d’elle. Un algorithme est une procédure finie, précise et générale, qui s’écrit en étapes numérotées, se suit à la main avec un tableau de suivi et se compose de séquence, de décision et de répétition ; chaque répétition s’accompagne d’un variant, une quantité naturelle qui décroît à chaque itération et garantit qu’elle se termine.

Programmes, compilateurs et C++

La leçon Programmes, compilateurs et C++ a montré que le texte d’un programme C++ ne s’exécute pas tel quel : le préprocesseur, le compilateur et l’éditeur de liens le transforment en un exécutable. De là est née la distinction qui traverse l’unité : ce qui dépend seulement du texte se découvre à la compilation ou à l’édition de liens, et ce qui dépend des données, seulement à l’exécution. La leçon a comparé le modèle compilé au modèle interprété et a justifié que le cours utilise C++23 et la demande avec -std=c++23.

Installer l’environnement

La leçon Installer l’environnement sous Windows, macOS et Linux a installé un compilateur capable de C++23 et Visual Studio Code avec son extension C++. Sa leçon de méthode est que l’éditeur ne compile pas, mais appelle un compilateur que le terminal doit trouver, et que le texte exact d’un message distingue la défaillance d’installation de la défaillance d’invocation.

Compiler, exécuter et configurer

La leçon Compiler, exécuter et configurer a fixé le cycle éditer, enregistrer, compiler, exécuter et lire, ainsi que la commande du cours. Elle a distingué l’erreur, qui empêche l’exécutable, de l’avertissement, qui le permet mais signale du code suspect ; elle a activé les détecteurs (celui des erreurs de mémoire, AddressSanitizer, et celui du comportement indéfini, UndefinedBehaviorSanitizer), qui surveillent l’exécution, et a montré leurs limites ; et elle a expliqué que fichier, compilateur et console doivent s’accorder sur UTF-8.

Anatomie d’un programme

La leçon Anatomie d’un programme a disséqué le programme minimal : les en-têtes, qui déclarent chaque dépendance ; main, point d’entrée dont la valeur est le code de sortie ; l’espace de noms std ; les instructions, les blocs et les commentaires. Elle a appris à lire les messages à partir du premier et a fixé le guide de style du cours.

Entrée, sortie et erreurs

La leçon Entrée, sortie et erreurs a mis le programme en contact avec l’extérieur : std::println écrit exactement ce qui est demandé, avec des spécifications de format, et std::cin lit et s’arrête au premier caractère qui ne convient pas. Une lecture qui bute sur un caractère qui ne peut pas former le nombre met la variable à zéro et laisse le flux en erreur, en silence (un nombre qui ne tient pas dans le type ou une entrée épuisée laissent une autre valeur dans la variable, et la leçon énumère ces cas) ; c’est pourquoi on vérifie la lecture. La leçon a clos l’unité en classant les erreurs selon leur moment : de compilation, d’édition de liens, d’exécution et de logique.