programmation en C"Chapitre4: Opérateurs logiques, expressions booléennes."

Chapitre 4 : Opérateurs logiques, expressions booléennes.
3.1 Opérateurs logiques
3.2 Variables booléenes et tables de vérité
3.3 Exercices
3.1 Opérateurs logiques
Dans le cadre des instructions conditionnelles, ou bien pour définir les limites des boucles, nous avons eu l'occasion de manipuler des conditions. Ce sont des expressions qui peuvent prendre deux valeurs possibles : soit vrai, soit faux. Toutes les conditions que nous avons vues jusqu'à présent étaient des comparaisons de valeurs : une valeur est-elle inférieure, supérieure, ou égale à une autre.
Cependant, on a souvent besoin de bien plus que d'une simple comparaison, pour prendre une décision. Par exemple, pour décider si un caractère est une minuscule, il faut vérifier que son code ASCII se trouve entre celui de la lettre 'a' et celui de la lettre 'z', ce qui demande deux comparaisons.
Pour exprimer ce type de conditions en langage C, on utilise ce que l'on appelle des opérateurs logiques. Par exemple, on pourra exprimer la conditon indiquant qu'un caractère est "après 'a', et avant 'z'", composée de deux comparaisons et d'un opérateur logique de type "et". En C, cette condition s'écrira : (caractere >= 'a') && (caractere <= 'z')

........

On a ici utilisé l'opérateur C '&&', qui se lit "et", et indique que la condition est vraie si l'expression de gauche et l'expression de droite sont toutes les deux vraies. On pourra ainsi avoir le programme C complet suivant : #include int main(){ char caractere; scanf("%c", &caractere); if ((caractere >= 'a') && (caractere <= 'z')) printf("Une minuscule\n"); else printf("Pas une minuscule\n"); return 0;}
Supposons que nous voulions maintenant tester si un caractère est la lettre 'a', que ce soit en minuscule ou majuscule. On peut écrire en français : "le caractère est un 'a' ou un 'A'", ce que l'on peut traduire en C grâce à l'opérateur '', qui se lit "ou" : (caractere == 'a') (caractere == 'A')
Une expression composée d'un opérateur '' est vraie si l'expression de gauche est vraie, ou que l'expression de droite est vraie. Elle est aussi vraie si les deux expressions sont vraies, et n'est fausse que dans le cas où les deux expressions sont fausses.
Il est bien sûr possible de former des expressions plus complexes, en ayant par exemple un opérateur '' ou '&&' entre deux expressions contenant elles-mêmes des opérateurs logiques. On utilisera des parenthèses pour bien séparer les sous-expressions. Par exemple, si l'on veut tester si un caractère est une lettre, que ce soit minuscule ou majuscule, on pourra écrire la condition suivante : ((caractere >= 'a') && (caractere <= 'z')) ((caractere >= 'A') && (caractere <= 'Z'))
L'expression à gauche du '' est vraie si le caractère est une lettre minuscule, et celle de droite est vraie si le caractère est une lettre majuscule. L'ensemble est donc vrai si le caractère est une lettre, minuscule ou majuscule.
Pour faciliter la lecture d'une telle condition, une bonne habitude à prendre consiste à la présenter sur deux lignes comme ci-dessus.
Le dernier opérateur logique du langage C permet d'exprimer la négation. Par exemple, si l'on veut vérifier qu'un caractère n'est pas une lettre majuscule, on dira en français : "le caractère n'est pas entre 'A' et 'Z'". En C, on utilise l'opérateur '!' qui placé devant une expression, indique que l'on en prend la négation : !((caractere >= 'A') && (caractere <= 'Z'))
Cette expression est vraie lorsque le caractère n'est pas une majuscule. On aurait très bien pu écrire cette expression autrement, en disant que pour qu'un caractère ne soit pas une lettre majuscule, il faut qu'il soit strictement avant 'A', ou strictement après 'Z' : (caractere < 'A') (caractere > 'Z')
Les deux notations sont parfaitement équivalentes, on choisira en pratique celle qui est la plus simple à comprendre.
Exercice : écrivez un programme qui lit un entier représentant une année, et affiche "bissextile" ou "non bissextile" en fonction de l'année. On rappelle qu'une année est bissextile si elle est un multiple de 4, à l'exception des années multiples de 100 qui ne sont pas multiples de 400. Par exemple, l'année 1900 n'est pas bissextile, mais l'année 2000 l'est.
Solution : Pour tester si une année est un multiple de 4, de 100 ou de 400, on utilisera l'opérateur '%'. Un entier est ainsi multiple de 4 si le reste de sa division par 4 vaut 0. #include int main(){ int annee; scanf("%d", &annee); if ((annee % 4 == 0) && ((annee % 100 != 0) (annee % 400 == 0))) printf("bissextile\n"); else printf("non bissextile\n"); return 0;}
3.2 Variables booléennes et tables de vérité
Toute expression qui peut valoir soit vrai soit faux, en C, est ce que l'on appelle une expression booléenne (du nom du mathématicien George Boole, inventeur de l'algèbre booléenne).
En C, les valeurs "vrai" et "faux" sont représentées respectivement par les entiers "1" et "0". Plus généralement, on considère que l'entier "0" vaut "faux", et que toute valeur non nulle est équivalente à "vrai".
Il est donc possible de stocker la valeur d'une expression booléenne, en utilisant une variable de type entier : int est_majuscule = (caractere >= 'A') && (caractere <= 'Z');
La variable est_majuscule vaudra ainsi 1 si la variable caractere contient une lettre majuscule, et 0 sinon.
On peut ainsi décomposer des expressions complexes en différentes expressions booléennes dont on stocke les valeurs : est_majuscule = (caractere >= 'A') && (caractere <= 'Z'); est_minuscule = (caractere >= 'a') && (caractere <= 'z'); est_lettre = est_majuscule est_minuscule;
De même, on peut utiliser des valeurs entières comme conditions : if (nombre % 2) printf("impair\n"); else printf("pair\n");
Dans cet exemple, le calcul nombre % 2 est effectué. Si le nombre est pair, le résultat vaut 0, et la condition est considérée comme fausse. Si le nombre est impair, le résultat vaut 1 pour un nombre positif, ou -1 dans le cas d'un nombre négatif, et la condition est vraie.
Il est cependant fortement déconseillé d'écrire de telles conditions, car elles manquent de clarté. On préférera ainsi le code suivant : if (nombre % 2 == 0) printf("pair\n"); else printf("impair\n");
Pour représenter le fonctionnement des divers opérateurs booléens, on utilise souvent les tables de vérité. Cela consiste à représenter toutes les possibilités de valeurs des expressions de gauche et droite de l'opérateur, et pour chaque possibilité, la valeur de l'ensemble. On peut ainsi représenter l'opérateur '' avec la table de vérité suivante :
a
b
a b
0
0
0
0
1
1
1
0
1
1
1
1
Sur la première colonne, on indique une valeur de l'expression de gauche, représentée par 'a'. La deuxième colonne indique la valeur de l'expression de droite, et la troisième colonne indique la valeur de l'ensemble de l'expression, pour les valeurs de a et b indiquées sur la ligne.
Exercice : représentez la table de vérité des opérateurs logiques '&&' et '!'. Ecrivez également la table de vérité de l'expression 'a (b && c)'.
Solution :
a
b
a && b
0
0
0
0
1
0
1
0
0
1
1
1

a
!a
0
1
1
0

a
b
c
a (b && c)
0
0
0
0
0
0
1
0
0
1
0
0
0
1
1
1
1
0
0
1
1
0
1
1
1
1
0
1
1
1
1
1
Exercice : écrivez en C une expression booléenne dont les valeurs correspondent à la table de vérité suivante :
a
b
expression
0
0
0
0
1
1
1
0
1
1
1
0
Solution :
Cette table de vérité correspond à l'opération logique "ou exclusif", que l'on écrit souvent "XOR" : l'expression est vraie si l'un des deux paramètres est vrai, mais pas les deux. Il n'y a pas d'opérateur logique en langage C permettant d'effectuer cette opération, mais on peut l'écrire à partir des autres opérateurs : (a && !b) (b && !a)
on peut aussi l'écrire : (a b) && !(a && b)
La première version s'exprime en français : soit a est vrai, mais pas b, soit b est vrai, mais pas a. La deuxième peut s'exprimer ainsi : on a soit a soit b, mais pas les deux à la fois.