Outils d'utilisateurs
calculs_arithmetiques
Différences
Cette page vous donne les différences entre la révision choisie et la version actuelle de la page.
|
calculs_arithmetiques [2014/06/15 15:24] 78.234.94.84 |
calculs_arithmetiques [2019/01/04 20:43] (Version actuelle) nico [Les nombres décimaux, hexadécimaux, octaux et binaires] |
||
|---|---|---|---|
| Ligne 1: | Ligne 1: | ||
| - | ^ [[hello_world|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[logique_et_calcul_booleen|Chapitre suivant]] ^ | + | ^ [[doc|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[logique_et_calcul_booleen|Chapitre suivant]] ^ |
| - | + | ||
| - | __ utilisation de sizeof ? __ | + | |
| ====== Les nombres entiers ====== | ====== Les nombres entiers ====== | ||
| - | Dans le chapitre précédent, vous avez appris à utiliser ''cout'' pour afficher des messages. Les messages sont des chaînes de caractères encadrées par des guillemets droits ". Une valeur écrite directement dans le code C++ est appelée une littérale. Il existe d'autres types de littérales : | + | Dans les chapitres précédents, vous avez appris à utiliser ''std::cout'' pour afficher des messages. Les messages sont des chaînes de caractères encadrées par des guillemets droits ". Une valeur écrite directement dans le code C++ est appelée une **littérale**. Il existe d'autres types de littérales, par exemple : |
| - | * les nombres entiers : ''0'', ''1'', ''2'', ''-1'', ''-2'', etc. | + | * les nombres entiers : ''0'', ''1'', ''2'', ''-1'', ''-2'' ; |
| - | * les nombres réels : ''1.0'', ''2.1'', ''-5.12'', ''1.457'', etc. | + | * les nombres réels : ''1.0'', ''2.1'', ''-5.12'', ''1.457'' ; |
| - | * les booléens, qui représente une valeur à deux états : ''true'' (vrai) et ''false'' (faux). | + | * les booléens, qui représentent une valeur à deux états : ''true'' (vrai) et ''false'' (faux) ; |
| - | * les caractères : 'a', 'b', 'c', etc. | + | * les caractères : 'a', 'b', 'c' ; |
| - | * et les chaînes de caractères que vous avez déjà vu : "hello, world", "salut tout le monde", etc. | + | * les chaînes de caractères (que vous avez déjà vu) : "hello, world", "salut tout le monde". |
| + | |||
| + | Remarquez bien la différence entre les caractères, qui s'écrivent avec des guillemets droits simples, et les chaînes, qui s'écrivent avec des guillemets droits doubles. Notez aussi que les nombres réels s'écrivent avec un point (notation anglaise) et non avec une virgule (notation française). | ||
| + | |||
| + | Vous pouvez afficher ces littérales directement en utilisant ''std::cout'', comme vous l'avez vu pour les chaînes de caractères. | ||
| + | |||
| + | <code cpp main.cpp> | ||
| + | #include <iostream> | ||
| + | |||
| + | int main() { | ||
| + | std::cout << 1 << std::endl; // nombre entier | ||
| + | std::cout << 3.1415 << std::endl; // nombre réel | ||
| + | std::cout << true << std::endl; // booléen | ||
| + | std::cout << 'a' << std::endl; // caractère | ||
| + | std::cout << "hello, world!" << std::endl; // chaîne de caractères | ||
| + | } | ||
| + | </code> | ||
| - | Vous pouvez afficher ces littérales directement en utilisant ''cout'', comme vous l'avez vu pour les chaînes de caractères. | + | Nous reviendrons par la suite sur les spécificités de chaque type de littérale, voyons pour le moment les nombres entiers plus en détail. |
| ===== Écrire des nombres entiers ===== | ===== Écrire des nombres entiers ===== | ||
| - | Les nombres entiers ne devraient pas vous poser de problème, ce sont les nombres que vous utiliser pour compter depuis l'école maternelle. La forme la plus simple pour écrire un nombre entier est d'écrire une série continue de chiffres entre 0 et 9. Les nombres ne doivent pas commencer par zéro. | + | Les nombres entiers ne devraient pas vous poser de problème, ce sont les nombres que vous utilisez pour compter depuis l'école maternelle. La forme la plus simple pour écrire un nombre entier est d'écrire une série continue de chiffres entre 0 et 9. |
| <code cpp main.cpp> | <code cpp main.cpp> | ||
| Ligne 44: | Ligne 58: | ||
| </code> | </code> | ||
| - | Lorsque vous écrivez de très grands nombres, il est difficile de le lire. Par exemple : | + | Lorsque vous écrivez de très grands nombres, il peut être difficile de les lire. Par exemple : |
| <code cpp main.cpp> | <code cpp main.cpp> | ||
| Ligne 54: | Ligne 68: | ||
| </code> | </code> | ||
| - | La raison est que le cerveau humain est capable de reconnaître des groupes de quelques caractères, mais pas un seul bloc de 18 caractères. Il n'arrive donc pas, en un coup d'oeil, à identifier si ce nombre est de l'ordre du million, du milliard ou autre. | + | La raison est que le cerveau humain est capable de reconnaître des groupes de quelques caractères, mais pas un seul bloc de 18 caractères. Il n'arrive donc pas, en un coup d’œil, à identifier si ce nombre est de l'ordre du million, du milliard ou autre. |
| - | Pour faciliter la lecture, il est donc possible d'ajouter un caractère guillemet droit ' pour séparer un grand nombre en plusieurs groupes. Par habitude, on séparera en groupes de trois chiffres : | + | Pour faciliter la lecture, il est possible d'ajouter un caractère guillemet droit simple ' pour séparer un grand nombre en plusieurs groupes. Par habitude, on sépare en groupes de trois chiffres : |
| <code cpp main.cpp> | <code cpp main.cpp> | ||
| Ligne 66: | Ligne 80: | ||
| </code> | </code> | ||
| - | Vous pouvez écrire des nombres très grand de cette manière, mais il existe une limite. Si vous écrivez un nombre trop grand, vous aurez un message d'erreur signalant que ce nombre est trop grand. | + | Notez bien la différence entre le guillemet droit simple utilisé pour écrire une littérale de type caractère et le séparateur numérique. Si la littérale commence par un un guillemet, elle sera considérée comme étant un caractère. |
| <code cpp main.cpp> | <code cpp main.cpp> | ||
| Ligne 72: | Ligne 86: | ||
| int main() { | int main() { | ||
| - | std::cout << 123456789123456789 << std::endl; // affiche le nombre 123456789123456789 | + | std::cout << 4'56 << std::endl; // ok, séparateur numérique |
| + | std::cout << '456 << std::endl; // erreur, guillemet manquant (1) | ||
| + | std::cout << '456' << std::endl; // erreur, plusieurs caractères (2) | ||
| } | } | ||
| </code> | </code> | ||
| - | Produira l'erreur : | + | La première erreur se produit du fait que le compilateur pense que le guillemet correspond au début d'une littérale caractère, mais ne trouve pas la fin. |
| <code> | <code> | ||
| - | main.cpp:4:18: error: integer constant is larger than the largest unsigned integer type | + | main.cpp:5:18: warning: missing terminating ' character [-Winvalid-pp-token] |
| - | std::cout << 123456789123456789123456789123456789 << std::endl; // affiche le nombre 123456789123456789 | + | std::cout << '456 << std::endl; |
| ^ | ^ | ||
| - | 1 error generated. | + | </code> |
| + | La seconde erreur correspond à une littérale caractère qui contient plusieurs caractères. | ||
| + | |||
| + | <code> | ||
| + | main.cpp:6:18: warning: multi-character character constant [-Wmultichar] | ||
| + | std::cout << '456' << std::endl; | ||
| + | ^ | ||
| + | </code> | ||
| + | |||
| + | Vous pouvez écrire des nombres très grands de cette manière, mais il existe une limite. Si vous écrivez un nombre trop grand, vous aurez un message d'erreur signalant que ce nombre est trop grand. | ||
| + | |||
| + | <code cpp main.cpp> | ||
| + | #include <iostream> | ||
| + | |||
| + | int main() { | ||
| + | std::cout << 123456789123456789123456789123456789 << std::endl; | ||
| + | } | ||
| + | </code> | ||
| + | |||
| + | produira l'erreur : | ||
| + | |||
| + | <code> | ||
| + | main.cpp:4:18: error: integer literal is too large to be represented in any integer type | ||
| + | std::cout << 123456789123456789123456789123456789 << std::endl; | ||
| + | ^ | ||
| </code> | </code> | ||
| L’existence d'une valeur maximale limite est liée à la représentation des nombres dans la mémoire des ordinateurs et à la notion de type de données. Vous verrez cela dans les prochains chapitres. | L’existence d'une valeur maximale limite est liée à la représentation des nombres dans la mémoire des ordinateurs et à la notion de type de données. Vous verrez cela dans les prochains chapitres. | ||
| - | <note info>Il est bien sûr possible d'utiliser des nombres avec autant de chiffre que vous souhaitez, mais il ne sera pas possible d'utiliser dans ce cas les nombres entiers tel que définit dans ce chapitre. Vous apprendrez à créer dans un travail pratique dans un prochain chapitre comment créer ce type de nombres entiers.</note> | + | <note info>Il existe des outils qui permettent d'utiliser des nombres avec autant de chiffres que vous souhaitez, mais il ne sera pas possible d'utiliser dans ce cas les nombres entiers tel que définis dans ce chapitre. Vous verrez par la suite quelques bibliothèques qui permettent de faire cela et pourrez implémenter ce type de fonctionnalités.</note> |
| ===== Les nombres décimaux, hexadécimaux, octaux et binaires ===== | ===== Les nombres décimaux, hexadécimaux, octaux et binaires ===== | ||
| - | Les nombres entiers que vous utilisez habituellement s'écrivent à partir de dix chiffres (0 à 9). C'est pour cette raison que l'on parle de système décimal (du latin "decimus", qui signifie "dixième") et l'on parle de base 10. Mais ce n'est pas la seule façon d'écrire les nombres et il existe d'autres systèmes numériques. | + | Les nombres entiers que vous utilisez habituellement s'écrivent à partir de dix chiffres (0 à 9). C'est pour cette raison que l'on parle de système décimal (du latin //decimus//, qui signifie "dixième") et de base 10. Mais ce n'est pas la seule façon d'écrire les nombres et il existe d'autres systèmes numériques. |
| - | + | ||
| - | Imaginons par exemple que l'on souhaite écrire les nombres en utilisant que huit chiffres (0 à 7). Dans ce cas, nous pouvons compter de la façon suivante : 0, 1, 2, 3, 4, 5, 6, 7. Arrivé au huitième chiffre, nous ne pouvons pas écrire "8", puisque ce chiffre n'est pas autorisé dans ce système décimal. Donc, il faut passer à un nombre à deux chiffres : 0, 1, 2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 14, 15, 16, 17, 20, 21, etc. | + | |
| - | Vous verrez dans les exercices comment convertir un nombre écrit selon une base dans une autre base. | + | Imaginons par exemple que vous souhaitez écrire des nombres en n'utilisant que huit chiffres (0 à 7 - base 8). Dans ce cas, nous pouvons compter de la façon suivante : 0, 1, 2, 3, 4, 5, 6, 7. Arrivé au huitième chiffre, nous ne pouvons pas écrire "8", puisque ce chiffre n'est pas autorisé dans ce système. Donc, il faut passer à un nombre à deux chiffres : 0, 1, 2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 14, 15, 16, 17, 20, 21, etc. |
| - | En C++, il est possible d'écrire et d'afficher des nombres écrit selon des bases différentes de 10. Pour des raisons historiques, les ordinateurs sont habitués à manipuler les nombres en base 2 (binaire), 8 (octal), 16 (hexadécimal). Pour écrire un nombre en base différente de 10, il faut commencer le nombre par le chiffre 0 puis un caractère pour spécifier la base : rien pour octal, x ou X pour l'hexadécimal et b pour le binaire. Les chiffres autorisés pour écrire un nombre dépendent également du mode : 0 à 7 pour l'octal, 0 à 9 et a à f (ou A à F) pour l'hexadécimal et 0 et 1 pour le binaire. | + | En C++, il est possible d'écrire et afficher des nombres écrits selon des bases différentes de 10. Pour des raisons historiques et matérielles, les ordinateurs savent manipuler les nombres en base 2 (binaire), 8 (octal), 10 (décimal) et 16 (hexadécimal). Pour écrire un nombre dans une base différente de 10, il faut commencer le nombre par le chiffre 0 puis un caractère optionnel pour spécifier la base : rien pour octal, ''x'' ou ''X'' pour l'hexadécimal et ''b'' pour le binaire. Les chiffres autorisés pour écrire un nombre dépendent de la base utilisée : de 0 à 7 pour l'octal, de 0 à 9 pour la décimal et de a à f (ou A à F) pour l'hexadécimal et 0 et 1 pour le binaire. |
| Le code suivant permet d'afficher la valeur de 10 selon la base : | Le code suivant permet d'afficher la valeur de 10 selon la base : | ||
| Ligne 122: | Ligne 160: | ||
| </code> | </code> | ||
| - | Il est possible calculer les conversions à la main, mais c'est plus simple d'utiliser un convertisseur. Il existe des convertisseurs en ligne, vous pouvez également utiliser la calculatrice de Windows en sélectionnant le mode "Programmeur" dans le menu "Affichage". | + | Il est possible de réaliser ces conversions à la main, mais c'est plus simple d'utiliser un logiciel de conversion. Il existe des convertisseurs en ligne, vous pouvez également utiliser la calculatrice de Windows en sélectionnant le mode "Programmeur" dans le menu "Affichage". |
| {{ :calculatrice.png |}} | {{ :calculatrice.png |}} | ||
| Ligne 135: | Ligne 173: | ||
| | ::: | ::: | 0X | 0 à 9 et A à F | ''0X0123456789ABCDEF'' | | | ::: | ::: | 0X | 0 à 9 et A à F | ''0X0123456789ABCDEF'' | | ||
| - | __ suffixe ? u l et ll __ | + | Comme vous l'avez vu dans les codes précédents, les nombres sont affichés après conversion en base 10. C'est le mode de fonctionnement par défaut de ''std::cout'', mais il est possible de modifier ce comportement. Les directives (//I/O manipulator//) suivantes permettent de modifier la base utilisée par ''std::cout'' pour afficher les nombres : |
| - | + | ||
| - | Comme vous l'avez vu dans les codes précédents, les nombres sont affichés après conversion en base 10. C'est le mode de fonctionnement par défaut de ''cout'', mais il est possible de modifier ce comportement. Les directives suivantes permettent de modifier la base utilisée par ''cout'' pour afficher les nombres : | + | |
| * ''std::oct'' pour afficher en utilisant la base 8 ; | * ''std::oct'' pour afficher en utilisant la base 8 ; | ||
| Ligne 143: | Ligne 179: | ||
| * ''std::hex'' pour afficher en utilisant la base 16. | * ''std::hex'' pour afficher en utilisant la base 16. | ||
| - | Il n'existe pas de directive permettant d'afficher les nombres en binaire, vous verrez dans un exercice dans un prochain chapitre comment afficher des nombres en binaire. Par défaut, ''cout'' affiche les nombres en utilisant la base 10. | + | Il n'existe pas de directive permettant d'afficher les nombres en binaire. Vous pourrez réaliser cela dans un exercice, dans la suite du cours. |
| <code cpp main.cpp> | <code cpp main.cpp> | ||
| Ligne 166: | Ligne 202: | ||
| </code> | </code> | ||
| - | Comme vous le voyez, une directive continue de s'appliquer sur toutes les lignes suivantes, tant que vous ne donner pas une directive modifiant une nouvelle fois l'affichage. Vous pouvez écrire les directives sur une ligne différente (comme dans le code précédent), sur la première ligne ou à chaque ligne, cela ne change rien au résultat. | + | Comme vous le voyez, une directive continue de s'appliquer sur toutes les lignes suivantes, tant que vous ne donnez pas une directive modifiant une nouvelle fois l'affichage. Vous pouvez écrire les directives sur une ligne différente (comme dans le code précédent), sur la première ligne ou à chaque ligne, cela ne change rien au résultat. |
| - | Si vous manipuler et afficher plusieurs bases, il peut être difficile de savoir exactement ce que vous afficher, avec quelle base. Il est dans ce cas possible d'afficher la base utilisée pour l'affichage avec la directive ''std::showbase''. Pour ne plus afficher la base, vous pouvez utiliser la directive ''std::noshowbase''. | + | <note>Faites bien la distinction entre des directives comme ''std::endl'', qui ont un effet immédiat, et les directives comme ''std::hex'', qui ont un effet permanent, jusqu'à ce qu'une autre directive modifie le comportement.</note> |
| + | |||
| + | Si vous affichez des nombres en utilisant plusieurs bases différentes, il peut être difficile de savoir à quelle base correspond chaque nombre affiché. Il est possible d'afficher la base utilisée pour l'affichage avec la directive ''std::showbase''. Pour ne plus afficher la base, vous pouvez utiliser la directive ''std::noshowbase''. | ||
| <code cpp main.cpp> | <code cpp main.cpp> | ||
| Ligne 178: | Ligne 216: | ||
| std::cout << 0x10 << std::endl; | std::cout << 0x10 << std::endl; | ||
| std::cout << 0b10 << std::endl; | std::cout << 0b10 << std::endl; | ||
| + | std::cout << std::endl; | ||
| std::cout << std::hex << std::showbase; | std::cout << std::hex << std::showbase; | ||
| Ligne 194: | Ligne 233: | ||
| 16 | 16 | ||
| 2 | 2 | ||
| + | |||
| 0xa | 0xa | ||
| 0x8 | 0x8 | ||
| Ligne 222: | Ligne 262: | ||
| </code> | </code> | ||
| - | Il est également possible de faire des divisions entières avec l'opérateur division ''/'' et de calculer le reste d'une division entière avec l'opérateur modulo ''%''. Pour rappel, la division entière permet de calculer le résultat d'une division en utilisant uniquement des nombres entiers (c'est le premier type de division que vous avez appris à l'école). Ainsi : | + | <note>Faites bien la distinction entre l'opération écrite entre guillemets "123 + 456", qui est donc interprétée comme une chaîne de caractères et non évaluée, et la même chose en dehors des guillemets, qui sera interprétée comme une expression mathématique et évaluée.</note> |
| - | * avec une division entière : 11 divisé par 4 donne 2 et reste 3 ; | + | Il est également possible de calculer des divisions entières avec l'opérateur division ''/'' et de calculer le reste d'une division entière avec l'opérateur ''%'' (cette opération s'appelle le "modulo"). Pour rappel, la division entière permet de calculer le résultat d'une division en utilisant uniquement des nombres entiers (c'est le premier type de division que vous avez appris à l'école). |
| - | * avec une division réelle : 11 divisé par 4 donne 2,75. | + | |
| + | {{ :division.png?150 |}} | ||
| + | |||
| + | En orange, le dividende. En bleu, le diviseur. En vert, le quotient (le résultat de la division entière). Et en jaune, le reste de la division (le modulo). Une division entière peut se réécrire sous forme d'une multiplication et d'une addition: | ||
| + | |||
| + | $$ 1234 = 56 \times 22 + 2 $$ | ||
| + | |||
| + | Et plus généralement, le reste d'une division entière est le nombre entier qui respecte l'équation suivante (toutes les variables étant des entiers), de façon a ce que le reste est compris entre 0 et le quotient-1. | ||
| + | |||
| + | $$ \text{dividende}= \text{diviseur}\times \text{quotient}+ \text{reste}\qquad (\text{avec} ~ 0 \leq \text{reste}< \text{quotient}) $$ | ||
| + | |||
| + | La division réelle retourne un nombre réel : | ||
| + | |||
| + | * avec une division entière : 1234 divisé par 56 donne 22 et reste 2 ; | ||
| + | * avec une division réelle : 1234 divisé par 56 donne 22,0357. | ||
| <code cpp main.cpp> | <code cpp main.cpp> | ||
| Ligne 251: | Ligne 305: | ||
| 10 % 4 = 2 | 10 % 4 = 2 | ||
| </code> | </code> | ||
| + | |||
| + | <note>En C++, l'opérateur ''/'' est utilisé pour faire les divisions entières et réelles. Il faut donc particulièrement faire attention de ne pas se tromper lorsque l'on écrit une expression, sous peine d'avoir des résultats étranges. | ||
| + | |||
| + | Le type de division (réelle ou entière) sera déterminé par le type des valeurs que vous utilisez : si les deux valeurs sont entières, cela sera une division entière. Si au moins une des deux valeurs est réelle, alors cela sera une division réelle. | ||
| + | |||
| + | <code cpp main.cpp> | ||
| + | #include <iostream> | ||
| + | |||
| + | int main() { | ||
| + | std::cout << "11 / 4 = " << 11 / 4 << std::endl; // division entière | ||
| + | std::cout << "11.0 / 4.0 = " << 11.0 / 4.0 << std::endl; // division réelle | ||
| + | std::cout << "11 / 4.0 = " << 11 / 4.0 << std::endl; // division réelle | ||
| + | std::cout << "11.0 / 4 = " << 11.0 / 4 << std::endl; // division réelle | ||
| + | } | ||
| + | </code> | ||
| + | |||
| + | affiche : | ||
| + | |||
| + | <code> | ||
| + | 11 / 4 = 2 | ||
| + | 11.0 / 4.0 = 2.75 | ||
| + | 11 / 4.0 = 2.75 | ||
| + | 11.0 / 4 = 2.75 | ||
| + | </code> | ||
| + | |||
| + | Comme vous le voyez dans ce code d'exemple, les nombres réelles sont écrit avec un point en C++ (notation anglaise) et non une virgule (comme en français). | ||
| + | </note> | ||
| Les opérations mathématiques suivent la sémantique habituelle, en particulier pour l'ordre d'évaluation et l'utilisation des parenthèses. Pour rappel, pour évaluer une expression mathématique (une série de plusieurs opérations), l'ordre d'évaluation est le suivant : | Les opérations mathématiques suivent la sémantique habituelle, en particulier pour l'ordre d'évaluation et l'utilisation des parenthèses. Pour rappel, pour évaluer une expression mathématique (une série de plusieurs opérations), l'ordre d'évaluation est le suivant : | ||
| Ligne 267: | Ligne 348: | ||
| </code> | </code> | ||
| - | Écrivez le code C++ correspondant pour évaluer cette expression et vérifier que le résultat est correct. | + | Pour exercice, écrivez le code C++ correspondant pour évaluer cette expression et vérifier que le résultat est correct. |
| - | De la même façon, les opérateurs du C++ suivent les règles d'arithmétiques habituelles : | + | De la même façon, les opérateurs du C++ suivent les règles arithmétiques habituelles : |
| - | * la commutativité (sauf pour la division) : a + b = b + a ; | + | * la commutativité : a + b = b + a (uniquement pour l'addition et la multiplication) ; |
| * l'associativité : a + (b + c) = (a + b) + c ; | * l'associativité : a + (b + c) = (a + b) + c ; | ||
| * la distributivité : a * (b + c) = a * b + a * c. | * la distributivité : a * (b + c) = a * b + a * c. | ||
| Ligne 309: | Ligne 390: | ||
| </code> | </code> | ||
| - | Un dernier point pour terminer : essayez de diviser un nombre entier par zéro : | + | ===== Les comportements indéfinis ===== |
| + | |||
| + | Un dernier point pour terminer, essayez de diviser un nombre entier par zéro : | ||
| <code cpp main.cpp> | <code cpp main.cpp> | ||
| Ligne 319: | Ligne 402: | ||
| </code> | </code> | ||
| - | affichera un avertissement à la compilation (//warning//) vous informant que la division par zéro n'est pas définie : | + | Ce code affichera un avertissement (//warning//) à la compilation, vous informant que la division par zéro n'est pas définie : |
| <code> | <code> | ||
| Ligne 325: | Ligne 408: | ||
| std::cout << (1/0) << std::endl; | std::cout << (1/0) << std::endl; | ||
| ^~ | ^~ | ||
| - | 1 warning generated. | ||
| </code> | </code> | ||
| - | On parle en C++ de "comportement indéfini", //undefined behavior// en anglais, que l'on abrège parfois avec les initiales "UB". Cela signifie qu'un programme utilisant un tel code aura un comportement aléatoire et faire n'importe quoi : provoquer une erreur, donner un résultat quelconque ou encore sembler fonctionner correctement. __Ce type d'erreur est difficile à diagnostiquer dans un programme complexe puisque cela ne produit pas forcement un message clair sur la ligne de code correspondant au problème.__ | + | On parle en C++ de "comportement indéfini", //undefined behavior// en anglais, que l'on abrège parfois avec les initiales "UB". Cela signifie qu'un programme utilisant un tel code aura un comportement aléatoire et pourra faire n'importe quoi : provoquer une erreur, donner un résultat quelconque ou encore sembler fonctionner correctement. Les comportements indéfinis sont difficiles à corriger, puisque cela ne produit pas forcement un message d'erreur clair. |
| - | Ainsi, l'exécution du programme précédent se déroule sans message d'erreur. Par contre, la valeur affichée par ''cout'' est aléatoire et n'a pas de sens en termes mathématique : | + | Ainsi, l'exécution du programme précédent se déroule sans erreur à l'exécution. Par contre, la valeur affichée par ''std::cout'' est aléatoire (dans coliru.com) et n'a pas de sens en termes mathématiques : |
| <code> | <code> | ||
| Ligne 336: | Ligne 418: | ||
| </code> | </code> | ||
| - | Le C++ étant un langage permissif, il n'y a aucune vérification faite par le langage pour éviter ce type d'erreur dans le code. C'est de votre responsabilité de vérifier que le code ne provoque pas de comportement indéfini. Pour cela, voici quelques aides : | + | Le C++ étant un langage permissif, le compilateur ne va pas nécessairement vérifier que vous écrivez du code incorrect. C'est de votre responsabilité de vérifier que le code ne provoque pas de comportement indéfini. Pour cela, voici quelques aides : |
| - | + | ||
| - | **Respectez les bonnes pratiques de codage**. Comme le C++ est permissif, le développeur a le droit d'écrire du code correct ou du code incorrect. Cela peut paraître évident, mais il vaut mieux le dire : il est préférable d'écrire du code correct que du code incorrect ! Il y a souvent plusieurs façon en C++ de résoudre un même problème, certaines approches posent plus de problèmes que d'autres. | + | |
| - | + | ||
| - | Ce cours de C++ n'a pas pour vocation à vous apprendre tout le C++. Il se focalise, volontairement, sur les syntaxes les plus récentes et les plus sûres. Et même en utilisant ces approches modernes, il y aura des précautions à prendre pour éviter les problèmes. Vous apprendrez à écrire du code le plus sûr possible. | + | |
| - | + | ||
| - | **Faites vous aider par le compilateur**. Celui-ci peut faire certaine vérifications, comme dans le code précédent, et vous avertir lorsque vous écrivez un code qui pose manifestement problème. Tous les compilateurs ne font pas forcement les mêmes vérifications et les vérifications faites dépendent des options utilisées. Les options ''-Wall -Wextra -pedantic'' activent les principales vérifications, mais il en existe d'autres. Il peut être intéressant de compiler un code avec plusieurs compilateurs pour avoir un maximum de messages d'avertissement. | + | |
| - | + | ||
| - | **Utilisez les outils de vérifications statique et dynamique**. Ils ne permettent pas simplement de vérifier le respect des règles du langage C++, mais également le respect de bonnes pratiques de codage. Dans l'objectif d'écrire des programmes C++ modernes, il ne faut pas hésiter à utiliser ce type d'outils et vous apprendrez dans la suite de cours à les utiliser. | + | |
| - | + | ||
| - | ===== Exercices ===== | + | |
| - | + | ||
| - | ==== Conversion en nombre de n'importe quelle base ==== | + | |
| - | http://fr.wikipedia.org/wiki/Syst%C3%A8me_d%C3%A9cimal | + | **Respectez les bonnes pratiques de codage**. Comme le C++ est permissif, le développeur a le droit d'écrire du code correct ou du code incorrect. Cela peut paraître évident, mais il vaut mieux le dire : il est préférable d'écrire du code correct que du code incorrect ! Il y a souvent plusieurs façons en C++ de résoudre un même problème, certaines approches posent davantage de problèmes que d'autres. |
| - | opérations à faire pour les calculs ? | + | Ce cours de C++ n'a pas pour vocation à vous apprendre tout le C++. Il se focalise, volontairement, sur les syntaxes les plus récentes et les plus sûres. Et même en utilisant ces approches modernes, il y aura des précautions à prendre pour éviter les problèmes. Vous apprendrez à écrire du code le plus sécurisé possible. |
| - | ==== Calculer l'indice de colonne et de ligne d'une table ==== | + | **Faites vous aider par le compilateur**. Celui-ci peut faire certaines vérifications, comme dans le code précédent, et vous avertir lorsque vous écrivez un code qui pose potentiellement un problème. Tous les compilateurs ne font pas les mêmes vérifications et les contrôles effectués dépendent des options utilisées. Les options ''-Wall -Wextra -pedantic'' qui vous ont été présentés dans coliru.com activent les principales vérifications, mais il en existe d'autres. Il peut être intéressant de compiler un code avec plusieurs compilateurs pour avoir un maximum de messages d'avertissement. |
| - | utilisation de / et % | + | **Utilisez les outils de vérification statique et dynamique**. Ce sont des outils qui font plus de vérifications que le compilateur. Les premiers vérifient le code directement, alors que les seconds travaillent sur le programme après compilation (donc durant l'exécution). |
| - | ===== Résumé ===== | + | Non seulement ils permettent de vérifier le respect des règles du langage C++, mais également que certaines pratiques de codage sont respectées. Dans l'objectif d'écrire des programmes C++ modernes, il ne faut pas hésiter à utiliser ce type d'outils. Vous verrez dans la suite de ce cours comment installer et utiliser certains de ces outils. |
| - | ^ [[hello_world|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[logique_et_calcul_booleen|Chapitre suivant]] ^ | + | ^ [[doc|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[logique_et_calcul_booleen|Chapitre suivant]] ^ |
| - | {{tag> Cours C++}} | ||
calculs_arithmetiques.1402838646.txt.gz · Dernière modification: 2014/06/15 15:24 par 78.234.94.84
Sauf mention contraire, le contenu de ce wiki est placé sous la licence suivante : CC Attribution-Noncommercial-Share Alike 3.0 Unported
