Qu’est ce qu’une condition ?
Si je vous dis :
Tu n’iras voir tes amis que si la table est ramassée.
Vous vous êtes surement rendu compte que la condition ici était :
» si la table est ramassée «
Et la conséquence est :
» tu iras voir tes amis «
C’est du programme de français au collège …
Quel rapport avec le C ?
Et bien ça marche exactement pareil. On a des conditions, et si elles sont vraies alors le programme exécute l'(es) instruction(s) rattaché(s) à cette condition.
Nous allons voir cela en détail, mais avant il est important pour vous que vous connaissiez quelques opérateurs essentiels au fonctionnement des conditions.
1 – Les signes indispensables
Voici la liste des opérateurs dit de comparaison, à retenir :
<strictement inférieur à …
<=inférieur ou égal à …
>strictement supérieur à …
>=supérieur ou égal à …
==égal à …
!=différent de … (non égal à …)
Maintenant la liste des opérateurs dit logiques,à retenir également :
||ou
&&et
!non
2 – Les booléens
A savoir : le terme booléen vient du nom du mathématicien et logicien anglais George Boole ( 1815 – 1864 ) qui développa ce qu’on appel, en son honneur : l’algèbre de Boole.
En C, l’évaluation logique des expressions obéit à la règle suivante :
– Une expression est logiquement fausse ( FALSE ), lorsque sa valeur numérique est 0.
– Une expression est logiquement vrai (TRUE ), lorsque sa valeur numérique est différente de 0.
Toute expression en C peut donc être testée sur sa valeur logique et sur sa valeur numérique. L’expression :
Code console:
2 + 1
à la valeur numérique 3 et est logiquement vrai car sa valeur diffère de 0. En revanche les expressions :
Code console:
0 x = 05 – 5 y * 0
ont toutes la valeur numérique 0. De ce fait, elles sont fausses et possèdent la valeur logique FALSE.
Les opérateurs de comparaisons vérifient l’existence d’une certaine relation entre les valeurs qui lui sont associés ( = opérandes ). Le résultat de cette vérification est une de deux valeurs : 0, si la condition est logiquement fausse et 1 si en revanche elle est vraie.
Prenons comme exemple :
x == y
si x est réellement égal à y alors l’expression x == y vaut TRUE. L’opérateur de compraison, dans ce cas, donne la valeur 1 à cette expression.
Si x n’était pas égal à y ( si x = 4 et y = 10 par exemple ) alors l’opérateur de comparaison donnerait la valeur 0 à cette expression car elle est logiquement fausse.
Si nous avons une variable :
Code c:
long x;
et l’affectation :
Code c:
x = ( 5 == 10 );
alors la variable reçoit la valeur 0.
Résumé :
si la valeur de l’expression de comparaison vaut :
0 alors la relation à vérifier n’existe pas, l’opérateur de comparaison ayant donc le résultat logique FALSE.
1 alors la relation existe, l’opérateur de comparaison ayant donc le résultat logique TRUE.
Petit programme pour illustrer les booléens :
Code c:
int main()
{
long x = 0, y = 0;
printf(« Ce programme compare la valeur de 2 nombres.n »);
printf(« Entrez deux entiers : n »);
printf(« x = « );
scanf (« %ld », &x);
printf(« y = « );
scanf(« %ld », &y);
printf(« Resultat pour x = %ld et y = %ld :n », x, y);
printf(« ( 1 = TRUE 0 = FALSE )nn »);
printf(« x = y ? ttt%ldn », x == y);
printf(« x different de y ? tt%ldn », x != y);
printf(« x plus petit que y ? tt%ldn », x < y);
printf(« x plus grand que y ? tt%ldn », x > y);
return 0;
}
Ce qui nous donne pour x = 5 et y = 2 :
Code console:
Ce programme compare la valeur de 2 nombres.
Entrez deux entiers :
x = 5
y = 2
Resultat pour x = 5 et y = 2 :
( 1 = TRUE 0 = FALSE )
x = y ? 0
x different de y ? 1
x plus petit que y ? 0
x plus grand que y ? 1
If
L’avantage d’une condition est qu’elle permet de ne pas réaliser systématiquement toutes les instructions mais seulement dans certains cas prévus par le programmeur. Dans ce contexte nous allons commencer par étudier l’instruction If.
L’instruction de test ou instruction If ( if = si en anglais ) permet de ne faire exécuter certaines instructions que dans le cas où une condition est remplie. Voici la syntaxe de If :
If simple :
If ( < expression > 
< instruction >;
La valeur entre parenthèse représente la condition du If. C’est d’elle que dépend ou non l’éxécution de l’instruction qui suit. Si la valeur de la condition est supérieur à zéro alors l’ instruction qui lui est associée sera éxécutée. En revanche si la valeur est nulle ( = 0 ) alors l’instruction ne sera pas éxécutée.
Voila un petit code pour illustrer If dans un programme :
Code c:
int main ()
{
long x = 5;
long y = 3;
/* si x est supérieur à y */
if ( x > y)
printf(« X est superieur a Y »);
return 0;
}
On initialise deux variables x et y. On remarque que x et bien supérieur à y. On fait ensuite appel à un test if : si la variable x et supérieur à la variable y alors affiche » X est supérieur à Y « .
Ici la variable x est belle et bien supérieur à y donc le message s’affichera. Mais maintenant si vous remplacez la valeur de la variable x par 2, le message ne s’affichera plus car la condition sera fausse.
Maintenant essayez ce code source :
Code c:
int main ()
{
long x = 2;
long y = 3;
if (!(x > y))
printf(« X est inferieur a Yn »);
return 0;
}
On remarque l’opérateur de négation » ! « . En gros que signifie cette condition ?
Et bien vu qu’on a » ! « , on pourrait traduire cela par :
Si x n’est pas supérieur à y.
Le » ! » sert à insérer une négation dans notre condition. Cela peut s’avérer très utile …
if complexe :
Jusqu’ici on a vu comment réaliser une instruction à partir d’une condition. Mais imaginez qu’on veuillent réaliser plusieurs instructions à partir de cette condition. Et bien il faudra rassembler ces conditions dans un block. En effet pour l’expression suivante :
Code c:
if ( variable == 4 )
printf(« variable = 4n »);
printf(« instruction de la condition »);
L’instruction :
Code c:
printf(« variable = 4n »);
ne s’affichera que si la condition est vraie. En revanche :
Code c:
printf(« instruction suivant celle de la condition »);
s’affichera peu importe la valeur de la condition. Si nous voulons que :
Code c:
printf(« instruction suivant celle de la condition »);
s’affiche seulement si la condition est vraie voila la syntaxe à respecter :
Code c:
if (variable == 4)
{
printf(« variable == 4n »);
printf(« instruction suivant celle de la condition »);
}
Comme dit plus haut, on regroupe toutes les instructions a réaliser en fonction de la valeur de la condition dans un seul et même block. Voila à quoi pourrait ressembler ce programme :
Code c:
int main ()
{
long variable = 4;
if (variable == 4)
{
printf(« variable = 4n »);
printf(« instruction suivant celle de la condition »);
}
return 0;
}
Voilà … à retenir car essentiel
3 – If / else
Nous avons vu comment réaliser une instruction en fonction de sa valeur logique maintenant voyons comment permettre une alternative à nos programmes. Pour cela nous allons nous baser sur un code qui demande l’âge de l’utilisateur. Si il a plus de 18 ans alors on affichera : vous êtes majeur. Sinon on afichera : vous êtes mineur.
Pour réaliser ce code il va nous falloir voir l’instruction « else » ( = sinon en anglais ). Voici sa syntaxe :
else
{
<instructions>
}
Plus simple que le if car il n’y a pas d’expression à vérifier. Et oui « else » pourrait se traduire en C par :
si l’expression du if est fausse alors fait ça.
A noter qu’à partir de maintenant toutes les instructions de nos conditions seront à mettre entre crochet. je vous demande de le faire afin d’éviter les erreurs.
Voyons maintenant le schéma du programme :
Demande l’âge
si l’âge est supérieur ou égal à 18 alors affiche » Vous êtes majeur «
sinon affiche » Tu es mineur «
Et maintenant à vous de jouer, réaliser ce programme, et vérifier votre code avec la solution qui suit :
Code c:
int main ()
{
long age = 0;
printf(« Quel est votre age ? « );
scanf(« %ld », &age);
/*Si age = 18 ou ( d’où l’opérateur || ) si age est > à 18 */
if (age == 18 || age > 18 )
{
printf(« Vous etes majeur »);
}
else
{
printf(« Tu es mineur »);
}
return 0;
}
Code console:
Quel est votre age ? 16
Tu es mineur
Quel est votre age ? 18
Vous etes majeur
Quel est votre age ? 77
Vous etes majeur
Simple, non ?
4 – Else If
En français else if se traduit par Sinon Si et bien en C, c’est pareil. Si la condition vaut cette valeur alors réalise ses instructions sinon si la condition vaut cette autre valeur réalise ses instructions, sinon fait cela.
Voila un code pour éclaircir les choses ( il doit vous rappelez des choses … ) :
Code c:
int main ()
{
long age = 0;
printf(« Quel est votre age ? « );
scanf(« %ld », &age);
if (age < 18 )
{
printf(« Tu es mineur »);
}
else if ( age == 18 )
{
printf(« Tu es tout juste majeur »);
}
/*si age est > 18 et ( && ) age est < à 130 */
else if (age > 18 && age < 130 )
{
printf(« Vous etes majeur »);
}
else
{
printf(« Tu dois etre tres age « );
}
return 0;
}
Voila pour le else if.
5 – switch, l’alternative
On vient de voir à l’instant que le test Else If nous permet d’étendre à volonté le nombre de choix. L’inconvénient de ce test se fait ressentir lorsque son apparition se fait trop régulière. De plus le manque de place pour une indentation conforme de diverses alternatives peut très vite rendre le code source illisible.
En fait, il existe une instruction spécifique pour le cas où il faudrait choisir plusieurs alternatives. Cette instruction se nomme » switch » et voici sa syntaxe :
switch < expression >
{
case valeur_1 : <instructions>;
break;
case valeur_2 : <instructions>;
break;
.
.
.
case valeur_n : <instructions>;
break;
default : <instructions>;
}
L’instruction switch doit toujours être suivie d’une expression de type entiere mise entre parenthèse. En général on y met le nom d’une variable. Le bloc qui suit contient un nombre quelconque de branches case. Chacune de ces branches se compose du mot clé case, et d’une valeur constante obligatoirement différente des autres, suivi ensuite du symbole » : « . Après le » : » on retrouve les instructions à exécuter si la valeur de l’expression située après le switch concorde avec une des constantes placés après le mot clé case.
Après cela on remarque le mot clé break. Il sert à sortir du switch afin d’éviter que le programme effectue toutes les autres instructions qui le suivent.
Enfin on peut voir défault, il sert uniquement si aucunes valeurs ne corresponds aux valeurs des constantes suivant les case.
Voici un code pour illustrer cela :
Code c:
int main ()
{
long nombre = 0;
printf(« 1, 2, 3 ou 4 ? : « );
scanf(« %ld », &nombre);
switch (nombre)
{
case 1 :
printf(« Vous avez tape 1n »);
break;
case 2 :
printf(« Vous avez tape 2n »);
break;
case 3 :
printf(« Vous avez tape 3n »);
break;
case 4 :
printf(« Vous avez tape 4n »);
break;
default :
printf(« Vous devez rentre 1,2,3 ou 4 ! »);
break;
}
return 0;
}
Voila …
Entrainez vous à réaliser de petits programmes utilisant des conditions, en effet les conditions sont souvent utilisées dans les programmes. Il faut savoir les manipuler …