La dernière fois, nous avons vu les variables, et nous avons introduit un embryon de calculs. Aujourd'hui, le seul et unique but dans ma vie est donc de compléter votre formation sur les expressions calculatoires, afin que vous deveniez des Jedi du calcul informatique.
L'écriture d'une expression
A long time ago, in a galaxy far far away... il y avait votre prof de maths qui vous expliquait comment on écrivait une fraction, une multiplication, etc... Vous avez appris que pour une fraction vous deviez mettre le numérateur au-dessus et le dénominateur en-dessous de la barre de fraction. De même, il vous a dit que si vous vouliez multiplier x par 2, vous pouviez écrire 2x.
Eh bien maintenant, il est temps d'oublier tout ça : vous n'écrirez jamais de fraction dans un programme, et vous devrez toujours mettre le signe de multiplication *. Regardez bien les deux lignes qui suivent :
2/(x+1)+3/5-y%2
1.5*4.3+40+x*x
Les expressions mathématiques
Ces deux lignes sont des expressions mathématiques. Ces expressions mathématiques peuvent comporter les symboles suivants :
|
|
- | * | / | % | ( | ) |
Une expression mathématique a pour résultat le résultat du calcul décrit.
Les expressions logiques
Il est souvent utile de comparer deux valeurs (ou expressions) entre-elles. On utilise pour cela les expressions logiques :
a<b
y==2
z!=0
Les symboles utilisés sont les symboles de comparaison, que voici :
|
< |
inf. ou égal <= |
supérieur > |
sup. ou égal >= |
égal == |
différent != |
Ces expressions ne peuvent prendre que deux valeurs: vrai ou faux. Le C++ réprésente la valeur vraie par la valeur numérique 1 et la valeur faux par 0. Inversement, toute valeur non-nulle est considérée comme vraie, et toute valeur nulle comme fausse. Ainsi, l'expression vraie x==x vaut 1, alors que x!=x vaut 0. Inversement, la valeur 3 est considérée comme vraie, alors que 0 est fausse (il s'agit d'un raccourci pour savoir si une variable est nulle ou non : au lieu d'écrire (x!=0), il suffit d'écrire (x), et au lieu d'écrire (x==0), il suffit d'écrire (!x)).
Une fois qu'on a comparé deux valeurs, on voudrait pouvoir combiner plusieurs comparaisons. Par exemple, comment faire si on veut savoir si x est compris entre 1 et 5? On pourrait croire qu'il suffit d'écrire :
1 < x < 5
Eh bien non! L'esprit malin de la paresse a encore frappé! Ce n'est pas aussi simple que ça. Cette expression est toujours vraie, car (1 < x) vaut soit 0 soit 1, et de toute façon, 0 et 1 sont inférieurs à 5. Cette expression reste donc toujours vraie. L'idée, c'est qu'il faut deux conditions : x doit être supérieur à 1 et il doit être inférieur à 5, c'est-à-dire (1 < x) et (x < 5).
Voici les 3 opérateurs qui nous servent à combiner des expressions logiques :
|
&& |
ou || |
non ! |
Voici les tables de vérité de ces opérateurs. 1 signifie vrai, 0 signifie faux.
| a | b | a && b | a || b | !a |
| 0 | 0 | 0 | 0 | 1 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 0 | 0 | 1 | 0 |
| 1 | 1 | 1 | 1 | 0 |
Reprenons l'exemple ci-dessus :
(1 < x) && (x < 5)
C'est pas plus difficile que ça. Voici quelques autres exemples pour la route :
(x <= 10) && (y <= 10) (x et y sont inférieurs à 10)
(x == 0) || (y%2 == 1) (x est nul ou y est impair, ou bien ...)
(!x) || (y%2) (... exactement la même chose, implicitement)
Sachez aussi que le C++ n'évalue pas plus d'expressions qu'il n'est nécessaire d'évaluer. Dans le premier des 3 exemples précédent, si (1 < x) est faux, le reste de l'expression est forcément faux, et (x < 5) n'est pas évalué.
Avec l'experience, vous apprendrez à maîtriser tout la finesse et la puissance de ces expressions ; elles sont très utiles, et elle ne sont vraiment pas difficiles à comprendre, ce qui tombe plutôt bien.
Avec tout ceci, vous devriez savoir faire tous les calculs dont vous pourriez avoir besoin. Rappelez-moi de vous parler plus tard des fonctions mathématiques comme sin, cos ou racine. C'est toute une autre histoire!
Les valeurs littérales
Les valeurs littérales sont les valeurs que vous écrivez dans votre programme. Elles peuvent représenter :
Lorsque vous écrivez une valeur littérale, elle a un type par défaut : les entiers sont des int, et les réels sont des float. Cependant, si les valeurs données sont trop grandes pour rentrer dans ces types, le type d'au-dessus sera choisi. Par exemple, la valeur 10000000000000 est trop grande pour rentrer dans un int, mais elle peut rentrer dans un long, elle est donc de type long. Pour les réels, le type dépend de la taille, mais aussi de la précision.
Lors de l'affectation d'une valeur littérale entière à une variable de type short, le compilateur vérifie que la valeur est assez petite pour rentrer dans un short, auquel cas la valeur est convertie et l'affectation se passe bien.
Par défaut, une valeur litérale est signed.
Le type d'une expression
Attention, maintenant vient la partie la plus obscure de ce cours. On a vu que toute variable avait un type. Rappelons les 6 types numériques :
short -> int -> long -> float -> double -> long double
Voici l'ordre dans lequel il faut les connaître. On dira (même si ça n'a pas vraiment de sens) que le short est le type le moins fort et que le long double est le type le plus fort. Ainsi, dans une expression, le compilateur cherche d'abord à savoir quel est le type le plus fort qui soit présent dans l'expression, et convertit toutes les autres valeurs à ce type avant d'effectuer le calcul. Voici deux exemples :
(3 * 2) est de type int
(3.5 * 2) est de type float, même si 3.5 * 2 = 7 est un entier.
L'opération de division présente un cas particulier : si elle se fait entre deux entiers, la division est une division entière. Ainsi, le résultat de (5 / 2) est 2, et non pas 2.5. Pour cela, il faudrait écrire (5.0 / 2).
Les conversions de types
Mais alors, comment faire si on fait une division entre deux variables entières, et qu'on veut un quotient réel? Il faut un moyen de préciser au compilateur un nouveau type pour une variable (bien sûr, sans en changer la valeur initiale). Reprenons l'exemple précédent, avec deux variables de type int : a et b. La division de a par b donnerait un quotient entier. Précisons alors qu'on veut prendre la valeur de a, et en faire un float : ((float)a) / b. a est un float, b est alors converti en float, et la division renvoie un quotient de type float.
Il est possible d'utiliser tous les types pour effectuer une conversion. Gardez simplement en tête qu'une conversion en arrière peut vous faire perdre des informations!
L'incrémentation
Je vous l'avais promis, je vais maintenant vous parler un peu de l'incrémentation. En effet, c'est une des opérations les plus courantes en informatique, à tel point que le C++ a réservé une notation spéciale à cet effet. Pour incrémenter une variable, mettons i par exemple, il suffit d'écrire i++ ou ++i. Voici un exemple :
| int i = 6; i++; cout << "i vaut: " << i << '\n'; |
Ce petit bout de programme affiche
i vaut: 7
La position de l'opérateur ++ ne joue un rôle que si l'incrémentation intervient dans une exression. Regardez bien :
| a = i++; | équivaut à | a = i; i = i + 1; |
| a = ++i; | équivaut à | i = i + 1; a = i; |
Bien sûr, il existe un opérateur de décrémentation qui fait exactement la même chose, mais dans l'autre sens : i--. Ces deux opérateurs sont très pratiques et très utilisés en C++, je vous conseille donc de les incorporer dès maintenant dans votre bac à reflexes, et de les utiliser le plus souvent possible.
L'opérateur d'incrémentation, ainsi que tous les autres opérateurs calculatoires sont présentés dans l'annexe Les opérateurs. La variable incrémentée peut être de n'importe quel type.
Les commentaires
Un petit dernier avant de se lancer dans le programme de cette fois-ci : commenter son programme. En effet, si il est très simple et relativement bien écrit, un programme est facilement compréhensible. Mais dès qu'on commence à se lancer dans des instructions et des manipulations obscures, le lecteur perd vite le fil de l'action. Les commentaires dans un programme ont plusieurs fonctions :
Je vous ai donné ces fonctions dans l'ordre d'importance : si vous ne voulez mettre que peu de commentaires, mettez-en seulement pour la première raison.
Le C++ offre deux façons d'écrire un commentaire :
Une des seules règles que je pourrais vous donner concernant les commentaires, c'est : commentez peu mais commentez bien. Il est complètement inutile de commenter des lignes qui sont parfaitement évidentes. La compétence d'un programmeur se mesure aussi à la pertinence de ses commentaires.
Mais trève de bavardages, je vais vous montrer tout de suite comment on les utilise. Voici le progamme du jour.
| 1 2 3 4 20 |
#include <iostream.h> main() { /* Ce programme va nous permettre d'illustrer } |
Dans ce programme, il n'y a que deux lignes qui devraient vous intriguer : le calcul de la nouvelle valeur de parite, ligne 17, et la fin de la ligne 19, avec le endl. Notez que ce programme pourrait très bien se passer des commentaires lignes 8, 15 et 16, ils ne sont là que pour vous montrer comment on les utilise. A l'avenir, je ne mettrais pas ou peu de commentaires dans mes programmes sur les pages de cours, car ils ne sont pas faciles à disposer correctement. Par contre, les fichiers sources contiendront tous les commentaires nécessaires.
Le second, vous pouvez le comprendre tout simplement comme un remplacement du caractère '\n'. C'est vrai que c'est moins fastidieux à écrire, si ce n'est pas le dernier caractère d'une string. C'est tout ce que vous avez à retenir pour l'instant.
Le calcul de parite est un peu plus mysterieux : d'abord, on demande à l'utilisateur de rentrer une valeur pour parite. Ensuite, la ligne 17 fait que si parite était pair, il prend la valeur 0, sinon, il prend la valeur 1. On a donc écrasé l'ancienne valeur. A partir de la nouvelle valeur, resultat prend soit la valeur de a, soit la valeur de b. Voici comment ça se passe :
L'important est que vous compreniez cette astuce, pas que vous la reteniez. En effet, il s'agit d'un bricolage que je suis obligé de faire car nous n'avons pas encore vu de façon d'assigner une certaine valeur à une variable en fonctions d'une condition. Mais rassurez-vous, c'est l'objet de notre prochain cours, et nous commencerons alors à toucher un peu plus les possibilités que nous offre la programmation.
Voici donc ce que vous devrez retenir aujourd'hui :
 |
|
Et puis les petites question rituelles (j'avoue qu'aujourd'hui je suis un peu à court d'inspiration) :
 |
|
Allez. Maintenant, on a assez trainé sur les bases, alors à partir du prochain cours, on va accélerer un peu. On va commencer les structures de sélection, ce qui nous permettra de faire des programmes un peu plus intéractifs. Accrochez vos ceintures... on set parti!!! ... Euh... y a quelqu'un? Personne ne m'aime? Ah! si, vous êtes là, vous, c'est gentil.
Voir aussi: Les opérateurs
