Alternatives
Booléens
Choix multiples
Accueil

du site

Alternative

Examinons ce court programme :

#include <stdio.h>
int main()
{
char entree;
printf("Voulez-vous un bonbon ?\n");
printf("Tapez O ou N en majuscules ! : ");

entree = getchar();//L'ordinateur attend la frappe d'une lettre
if(entree == 'O')
printf("Vous avez répondu OUI, mais je n'ai pas de bonbons !\n");
else
printf("Vous n'avez pas répondu OUI, tan pis pour vous !\n");
return 0;
}

Commentaires :

Dans ce programme, propose un bonbon au client qui s'est aventuré à le lancer.

La procédure "getchar()" de la librairie des programmes d'entrée sortie clavier-console <stdio>,
attend qu'une touche soit frappée et renvoie le caractère sorrespondant dans la variable entree.

Si le caractère entré est un 'O' majuscule le programme s'excuse très hypocritement et s'arrête.
Si ce n'est pas un 'O' majuscule, il vous nargue non moins hypocritement et s'arrête aussi.
Notez que 'X' entre apostrophes signifie "valeur numérique" ou code ASCII du caractère X.

Un choix entre deux solutions s'appelle une alternative.
Dans ce programme, l'alternative est simple : la lettre frappée au clavier est ou n'est pas un 'O' majuscule.

Le schéma général d'une alternative en C est :

if( condition )
instruction_a _exécuter_si_condition_réalisée;
else
instruction_a _exacuter_si_condition_non_réalisée;
Nous rappelons qu le mot anglais "if" signifie "si" - le si conditionnel - en français.
et que le mot "else" signifie "autrement" - "dans le cas contraire".
En somme l'alternative est facile à comprendre.

Il se peut qu'il y ait plus d'une instruction à réaliser dans chaque cas :

if( condition )
{
instruction1_a _exécuter_si_condition_réalisée;
instruction2_a _exécuter_si_condition_réalisée;
instruction3_a _exécuter_si_condition_réalisée;
//etc
}
else
{
instruction1_a _exécuter_si_condition_non_réalisée;
instruction2_a _exécuter_si_condition_non_réalisée;
instruction3_a _exécuter_si_condition_non_réalisée;
//etc
}


Variables booléennes


Penchons-nous maintenant sur le contenu des parenthèses après le "if" : ( entree == 'O')

Ce double signe égal ( == ) n'est pas une erreur de frappe.

Souvenez-vous que le signe égal simple n'a pas dans le langage C une fonction d'égalité mais d'afféctation d'une valeur à une variable comme dans x = 3 ;

Le signe " == " au contraire, évalue si les deux termes qui sont, l'un à sa gauche, l'autre à sa droite, ont une valeur égale.
Si oui , il donne au contenu des parenthèses la valeur "vrai" : "true" en anglais et aussi en langage C.
Si non, il donne au contenu des parenthèses la valeur "faux" : "false" en anglais et aussi en langage C.

Le contenu des parenthèses, est donc d'un type particulier appelé booléen "boolean" en anglais et en C.
Ce type, nouveau pour nous, ne peut prendre que deux valeurs "true" ou "false"

L'opérateur " == " est donc un opérateur booléen.
Il évalue l'égalité des deux variables qui l'entourent.
Il retourne une valeur booléenne.

Les deux variables de part et d'autre de l'opérateur " == " doivent être du même type, quel que soit ce type.
Elles peuvent être des caractères, des entiers, des flottants, etc.

Nous paufinons en conséquence la structure générale d'une alternative :

if( booleen )
{
instruction1_a _exécuter_si_booleen_true;
instruction2_a _exécuter_si_booleen_true;
instruction3_a _exécuter_si_booleen_true;
//etc
}
else
{
instruction1_a _exécuter_si_booleen_false;
instruction2_a _exécuter_si_booleen_false;
instruction3_a _exécuter_si_booleen_false;
//etc
}
Suite des instructions du programme ;

On peut rencontrer des formes incomplètes du genre :

if( booleen )
{
instruction1_a _exécuter_si_booleen_true;
instruction2_a _exécuter_si_booleen_true;
instruction3_a _exécuter_si_booleen_true;
//etc
}

Suite des instructions du programme ;

 

Opérateurs booléens

 

Opérateurs
Assertion
Opérandes a et b
a == b
a égale b
numériques
caractères
a != b a différent de b numériques
caractères
a < b
a inférieur à b
numériques
a <= b
a inférieur ou égal à b
numériques
a > b
a supérieur à b
numériques
a >= b
a supérieur ou égal à b
numériques

Les signes doubles doivent être accolés (pas de blanc entre eux)

Une "astuce" de programmation :

Vous ne verrez jamais un programmeur confirmé écrire ceci en langage C : if(a != 0) ou if(a == 0)
En effet, le langage C, contrairement aux langages très fortement typés tels que Pascal, fait peu de différence entre un entier et un booléen.

Un entier nul est équivalent, pour C, à un booléen de valeur false.
Un entier non nul est équivalent, pour C, à un booléen de valeur true..

Dès lors, l'assertion ( a != 0 ) est équivalente à ( a ) tout court.

On vérifie ?
Si a est nul le booléen ( a != 0 ) est faux.
Si a est nul le booléen ( a ) est faux car d'après ce qui a été dit plus haut, zéro est équivalent à faux.
Si a est non nul, le booléen ( a != 0 ) est vrai.
Si a est non nul, le booléen ( a ) est vrai car d'après ce qui a été dit plus haut, non nul est équivalent à vrai
Alors, pour faire plus court, on écrira if(a) plutôt que if(a != 0).

Nous le ferons systématiquement dans toute la suite de nos programmes.


Opérateurs combinatoires

Ce sont des opérateurs de logique combinatoire agissant sur des opérandes booléens.

Opérateurs
Opération
Opérandes a et b
a && b
a et b
booléens
a || b a ou b booléens
|a non a booléen

Voici un petit programme d'essai.

#include <stdio.h>

int main()
{
char entree;
printf("Voulez-vous un bonbon ?\n");
printf("Tapez O ou N en majuscules ! : ");

entree = getchar();//L'ordinateur attend la frappe d'une touche
if((entree =='O') || (entree =='o'))
printf("Vous avez répondu OUI, mais je n'ai pas de bonbons !\n");
else
printf("Vous n'avez pas répondu OUI, tan pis pour vous !\n");
return 0;
}

Notez que 'X' entre apostrophes signifie "valeur numérique" ou code ASCII du caractère X.

Nous avons rencontré un programme semblable plus haut.
La différence est que l'on a remplacé
if(entree =='O')
par if((entree =='O') || (entree =='o'))
dans le premier cas, il fallait que l'opérateur entre un 'O' majuscule pour signifier "OUI".
désormais il put entrer un 'O' majuscule ou un 'o' minuscule.

Autre exemple : supposons que l'on veuille savoir si l'opérateur a entré un chiffre.

#include <stdio.h>

int main()
{
char entree;
printf("Tapez un chiffre : ");
entree = getchar();//L'ordinateur attend la frappe d'une touche

if ((entree >= '0') && (entree <= '9'))
printf("Vous avez bien entré un chiffre !\n");
else
printf("Vous n'avez pas entré un chiffre !\n");
return 0;
)

La séquence ((entree >= '0') && (entree <= '9')) est basée sur le fait que les codes ASCII des lettres et des chiffres sont dans le même ordre alphanumérique que les caractères qu'ils représententt Par exemple le code de b est inférieur de 1 au code de c. Le code de 3 est égal au code de 2 plus 1.
Voir codes ASCII
Le code entré sera celui d'un chiffre si l'entrée est supérieure ou égale au code de zéro "0" et inférieur ou égale au code de neuf '9'.


Choix multiples


Il arrive que l'on ait à distinguer plusieurs cas suivant la valeur d'un nombre ou d'un caractère.

Exemple : dans un annuaire téléphonique, on peut avoir à demander à l'opérateur son choix sur l'action à mener : visualiser une fiche, en ajouter une en supprimer une, ou quitter le programme.

La séquence ci-dessous se limite à la partie du code correspondant à ce choix.

#include <stdio.h>

int main()
{
char entree;
printf("Tapez 'V' pour visualiser une fiche,\n");
printf("Tapez 'A' pour ajouter une fiche,\n");
printf("Tapez 'S' pour supprimer une fiche,\n");
printf("Tapez 'Q' pour quitter le programme : ");
entree = getchar();//L'ordinateur attend la frappe d'une touche

switch(entree)
{
case 'v' :
case 'V' : ProgrammeDeVisualisation();
break;

case 'a' :
case 'A' : ProgrammeAjoutDeFiche();
break;

case 's' :
case 'S' : ProgrammeDeSuppressionDeFiche();
break;

case 'q' :
case 'Q' : PreparationAQuitter();
break;

default : printf("Entrez 'V'ou 'A' ou 'S' ou 'Q' SVP !\n");
}

//suite du programme
return 0;
)

Bien que le code soit évident, nous faisons ci-dessous quelques remarques :

Observez que case : 'a' et case 'A' se suivent sans l'instruction break interposée.
L'une ou l'autre des entrées 'a' ou 'A' appellera la fonction ProgrammeAjoutDeFiche()puis, dès le break atteint, sortira du bloc switch vers la suite du programme.
Cela explique la fonction de l'instuction break : aiguiller vers la sortie du bloc switch. bloquer permet de s'aiguiller sur la sortie. Sinon une fois que quence.

Une action par défaut est prévue dans le cas où l'opérateur taperait une autre touche que celles proposées.

Plusieurs instructions sucessives peuvent être rattachées à un choix particulier :
......
case 's' :
case 'S' : printf("Vous avec demandé une suppression");
 ProgrammeDeSuppressionDeFiche();
 break;
......


La suite : algorithmes.
Sommaire Langage C
Accueil

du site