Synthèse et défis : données et types

L’acquis de l’unité

L’unité s’est proposé d’enseigner que toute donnée vit en mémoire avec un type qui fixe quelles valeurs elle peut prendre, combien de place elle occupe et quelles opérations elle admet, et que ces limites ont des conséquences observables. Le but a été atteint en s’appuyant seulement sur ce que l’introduction a déclaré acquis : le cycle compiler et exécuter avec les options du cours, la sortie formatée, la lecture avec std::cin et la lecture des messages du compilateur. Le programme des quatre calculs par lequel l’introduction a posé le problème peut maintenant être expliqué ligne par ligne, et corrigé.

Variables et mémoire

La leçon Variables et mémoire a établi qu’une variable est une case mémoire dotée d’un nom, d’un type fixe et d’une valeur qui change, et que le type fixe sa taille, que sizeof mesure. Elle a distingué l’initialisation de l’affectation, montré que les accolades refusent une conversion avec perte, et enseigné que l’affectation copie et ne lie pas, et que la valeur remplacée est perdue, d’où découle la variable auxiliaire de l’échange. Elle a défini l’état d’un programme comme l’ensemble des valeurs de ses variables et appris à le suivre avec un tableau de suivi. Elle a fixé les conventions de nommage et s’est terminée sur le premier comportement indéfini de l’unité : la lecture d’une variable qui n’a jamais reçu de valeur.

Les entiers et leur représentation

La leçon Les entiers et leur représentation a enseigné la notation positionnelle en bases 10, 2 et 16. Du fait qu’un type a $n$ bits, elle a déduit sa plage : $2^n$ motifs, qui représentent, sans signe, de $0$ à $2^n - 1$ et, avec signe, en complément à deux, de $-2^{n-1}$ à $2^{n-1} - 1$, avec un nombre strictement négatif de plus que de strictement positifs. Elle a distingué les deux dépassements : celui des entiers non signés, qui est une arithmétique modulo $2^n$ et est défini (0u - 1 vaut $4\,294\,967\,295$), et celui des entiers signés, qui est un comportement indéfini et que le détecteur arrête. Elle a montré que comparer un entier signé avec un entier non signé convertit le premier, de sorte que $-1 < 0u$ est faux, et s’est terminée par un critère pour choisir le type entier selon la plage prévisible de la donnée.

Les nombres à virgule flottante

La leçon Les nombres à virgule flottante a montré qu’un réel est stocké comme un signe, un exposant et une mantisse binaire, de sorte que les valeurs représentables forment un ensemble fini de rationnels dont le dénominateur est une puissance de 2. Il en a découlé que $0.1$ n’existe pas dans la machine : à sa place on stocke le double le plus proche, et 0.1 + 0.2 s’écrit 0.30000000000000004. La leçon a borné l’erreur de chaque arrondi, montré que les erreurs s’accumulent et que l’addition cesse d’être associative ; d’où elle a déduit que deux réels calculés ne se comparent pas avec ==, mais par leur distance, avec une tolérance justifiée. Elle a fixé double comme type réel par défaut, et présenté l’infini et la valeur non numérique, NaN.

Caractères, booléens, conversions et constantes

La leçon Caractères, booléens, conversions et constantes a montré qu’un type est une règle pour lire les bits : un char stocke un octet dont la valeur est le code ASCII du caractère, et comme les chiffres et les lettres ont des codes consécutifs, '7' - '0' vaut 7 ; un bool est vrai ou faux, et tout nombre non nul se convertit en vrai. Elle a étudié les conversions implicites et établi que la conversion a lieu dans l’opération, selon le type des opérandes, et non au moment de stocker le résultat : double r{7 / 2} vaut 3. Elle a appris à écrire la conversion voulue avec static_cast, qui n’évite pas la perte, mais la déclare ; elle a précisé que les accolades refusent le rétrécissement, et montré le troisième comportement indéfini de l’unité, la conversion en entier d’un réel qui ne tient pas. Elle s’est terminée par les constantes (const, constexpr et static_assert), le type des littéraux et auto.