Le C en 20 heures


précédentsommairesuivant

V. Conditions

V-A. Objectif

Dans ce chapitre, nous allons voir comment introduire des conditions dans nos programmes, de manière à ce que selon les circonstances, telle ou telle partie du code soit exécutée.

V-B. Exercice de mise en bouche

Écrivez un programme qui met en application le théorème de Pythagore pour calculer la longueur de l'hypoténuse d'un triangle rectangle.

Rappelons que dans un triangle rectangle, la longueur de l'hypoténuse (le plus grand côté) peut se calculer en appliquant la formule suivante :
Longueur hypoténuse = Image non disponible
a et b sont les longueurs des deux autres côtés.

La racine carrée s'obtient par l'utilisation de la fonction sqrt(valeur) contenue dans la bibliothèque de mathématiques (#include <math.h>)

a2 peut s'obtenir par a*a.

Image non disponible Exercice n°4.1 — Pythagore

  1. Recherchez les variables nécessaires et déclarez-les dans le programme.
  2. Faites saisir a au clavier.
  3. Faites saisir b au clavier.
  4. Appliquez la formule et affichez le résultat.

Rappelons que, afin de pouvoir utiliser la bibliothèque mathématique du C (#include <math.h>), il est nécessaire d'ajouter au moment de la compilation -lm (un tiret, la lettre l, la lettre m) ce qui nous donne :

 
Sélectionnez
gcc -o monprog monprog.c -lm

Une fois que vous êtes satisfait(e) de votre solution, vous pourrez comparer avec la solution qui se trouve à la fin de ce chapitre.

V-C. Condition : Si Alors Sinon

En français, nous pourrions dire quelque chose de ce type :

 
Sélectionnez
si (je travaille)
alors je progresserai
sinon je stagnerai

En se rapprochant un peu du Langage C, on traduirait (toujours en français) ce premier programme ainsi :

 
Sélectionnez
si (je travaille) {
   alors je progresserai
}
sinon {
   je stagnerai
}

Enfin, le programme en Langage C ressemblera à ceci :

 
Sélectionnez
if (je travaille) {
   je progresserai
}
else {
   je stagnerai
}

Les conditions s'expriment avec des opérateurs logiques dont nous allons expliquer tout de suite la signification et l'utilisation.

V-D. Opérateurs de comparaison

Ils servent à comparer deux nombres entre eux : 

Table 4.1 - Opérateurs de comparaison
Signification Opérateur
Inférieur <
Supérieur >
Égal ==
Différent !=
Inférieur ou égal <=
Supérieur ou égal >=

Voici un exemple de programme qui demande à l'utilisateur de saisir deux valeurs puis affiche la plus grande :

 
Sélectionnez
#include <stdio.h>
int main () {
   int   valeur1;
   int   valeur2;
   /* Saisie de valeur1 */
   printf ("Entrez une 1ere valeur : ");
   scanf ("%d",&valeur1);
   /* Saisie de valeur2 */
   printf ("Entrez 2eme valeur : ");
   scanf ("%d",&valeur2);
   if (valeur1<valeur2)
      printf("La plus grande valeur est: %d\n",valeur2);
   else
      printf("La plus grande valeur est: %d\n",valeur1);
   return 0;
}

V-E. Opérateurs logiques

Les opérateurs logiques permettent de combiner des expressions logiques. 

Table 4.2 - Opérateurs logiques
Libellé Opérateur
Et (and) &&
Ou (or) ||
Non (not) !

« | » se nomme en anglais un pipe (prononcer païpe). Des exemples suivront bientôt…

V-F. Vrai ou faux

La valeur Vrai peut être assimilée à la valeur numérique 1. En programmation C, la valeur Vrai est associée à toute valeur non nulle.

La valeur Faux peut être assimilée à la valeur numérique 0.

L'opérateur Ou (||) correspond alors à une addition : 

Table 4.3 - L'opérateur ou
Ou VRAI FAUX
VRAI VRAI VRAI
FAUX VRAI FAUX
 
Table 4.4 - L'opérateur ou : analogie avec l'addition
+ 1 0
1 2 1
0 1 0

En lisant la valeur donnée à l'intersection de la ligne et de la colonne, on obtient donc le résultat de notre opération. Par exemple :

Ligne 1 / Colonne 1, VRAI ou VRAI donne VRAI, 1+1=2 (soit Vrai)

En logique pure, on écrira plus 1+1=1 du fait que toute valeur non nulle est considérée comme Vrai.

L'opérateur Et (&&) correspond alors à une multiplication(16) : 

Table 4.5 - L'opérateur et
Et VRAI FAUX
VRAI VRAI FAUX
FAUX FAUX FAUX
 
Table 4.6 - L'opérateur et : analogie avec la multiplication
* 1 0
1 1 0
0 0 0

En lisant la valeur donnée à l'intersection de la ligne et de la colonne, on obtient donc le résultat de notre opération. Par exemple :

Ligne 1 / Colonne 1, VRAI et VRAI donne VRAI, 1*1=1 (soit Vrai)

L'opérateur Not (!) permet d'obtenir la négation, ainsi :
!(Vrai) = Faux
!(Faux) = Vrai

Par exemple :
 
Sélectionnez
int i1=1;
int i2=0;
printf("i1 || i2 = %d",i1||i2);
   /* affichera 1 car : vrai||faux=vrai et vrai vaut 1 */
printf("i1 && i2 = %d",i1&&i2);
   /* affichera 0 car : vrai&&faux=faux et faux vaut 0 */
printf("contraire(1)=%d",!(1));
   /* affichera 0 car : !(vrai)=faux et faux vaut 0 */

V-G. Combinaison

Toutes les opérations logiques peuvent se combiner entre elles. Il faut néanmoins veiller aux différentes priorités des opérateurs et il faut que la condition dans sa totalité soit entourée de ().

Les exemples suivants montrent ce qui est possible et ce qui ne l'est pas : 

Table 4.7 - Opérateurs : formulations correctes et incorrectes
Correct
Incorrect
if (car == 'a')
if car == 'a'
Correct
Incorrect
if ( car == 'a' || car == 'A')
if (car == 'a') || (car == 'A')
Correct
Incorrect
if ((c == 'a' || c == 'A') && (c2 == 'G'))
if (c == 'a' || c == 'A') && (c2 == 'G')

Vous verrez souvent ce type de code écrit :

 
Sélectionnez
if (er) {
   /* Alors faire quelque chose */
}

En appliquant ce qui a été vu précédemment, on en déduit que ce code signifie que

 
Sélectionnez
si (er != 0)   /* si er différent de 0 */
{
   /* Alors faire quelque chose */
}

Ce qui donne en Langage C :

 
Sélectionnez
if (er != 0) {   /* si er différent de 0 */
   /* Alors faire quelque chose */
}

Dans l'immédiat, préférez if(er!=0) à if (er) !!!

V-H. Accolades

Les accolades entourant les blocs d'instructions d'une condition peuvent être omises si le bloc n'est constitué que d'une seule instruction.

Voici une version lourde :
 
Sélectionnez
/* VERSION LOURDE : */
if (car == 'b') {
   printf ("car vaut b.");
}
else {
   printf ("car est différent de b.");
}

Voici une version plus légère :
 
Sélectionnez
/* VERSION LEGERE : */
if (car == 'b')
   printf ("car vaut b.");
else
   printf ("car est différent de b.");

Au contraire, dans l'exemple ci-dessous, il faut impérativement mettre des accolades !

 
Sélectionnez
if (car == 'b') {  // il y a 2 instructions donc on met des { }
   printf ("car vaut ");// 1ère instruction
   printf(" %c",car);// 2ème instruction
}
else
   printf ("car est différent de b.");

V-I. Exercices

Image non disponible Exercice n°4.2 — Variable positive, négative ou nulle

Faites saisir une variable de type entier et indiquez à l'utilisateur si celle-ci est strictement positive, strictement négative ou nulle. Votre code contiendra quelque chose comme ceci :

 
Sélectionnez
if (a > 0)
   printf ("Valeur positive");
else
   printf ("Valeur négative");

Image non disponible Exercice n°4.3 — Voyelles, consonnes

Faites saisir une variable de type caractère et indiquez à l'utilisateur si celle-ci est une voyelle ou une consonne. On considérera que le caractère saisi est en minuscule.

Notez que si le caractère saisi est une lettre et n'est pas une voyelle, c'est nécessairement une consonne.

V-J. Corrections des exercices du chapitre

Image non disponible Corrigé de l'exercice n°4.1 — Pythagore

 
Sélectionnez
#include <stdio.h> 
#include <math.h> 
int main () {
   float   h;  /* valeur de l'hypoténuse  */
   float   a;  /* a,b les deux autres côtés */
   float   b;
   /* Initialisation des variables par précaution */
   a = 0;
   b = 0;
   /* Saisie de a */
   printf ("Valeur du premier petit côté : ");
   scanf ("%f",&a);
   /* Saisie de b */
   printf ("Valeur du second petit côté : ");
   scanf ("%f",&b);
   /* Calcul de la longueur de l'hypoténuse */
   h = sqrt (a*a + b*b);
   /* Affichage du résultat */
   printf ("L'hypoténuse mesure : %.2f\n",h);
   /* Attendre avant de sortir */
   getchar ();
   return 0;
}

Image non disponible Corrigé de l'exercice n°4.2 — Variable positive, négative ou nulle

 
Sélectionnez
#include <stdio.h> 
int main () {
   /* Variable pour stocker la valeur saisie */
   int a = 0;
   /* Saisie de a */
   printf("Saisie de a : ");
   scanf("%d",&a);
   /* Strictement négative ? */
   if (a < 0)
      printf("la variable a est négative.\n");
   else {
      /* Strictement positive ? */
      if (a > 0)
         printf("la variable a est positive\n");
      /* Sinon a est nulle */
      else
         printf("la variable a est nulle\n");
   }
   getchar ();
   return 0;
}

Image non disponible Corrigé de l'exercice n°4.3 — Voyelles, consonnes

 
Sélectionnez
#include <stdio.h> 
int main () {
   /* Variable pour stocker la valeur saisie */
   char car;
   /* Saisie du caractère a */
   printf("Saisie du caractère : ");
   scanf("%c",&car);
   /* Test condition car voyelle minuscule */
   if ((car == 'a') || (car == 'e') || (car == 'i') || (car == 'o') || (car =='u') || (car == 'y'))
      printf("la variable car est une voyelle.\n");
   else
      printf("la variable car est une consonne.\n");
   getchar ();
   return 0;
}

V-K. À retenir

  • La valeur Vrai peut être assimilée à la valeur numérique 1 ou à toute valeur non nulle.
  • La valeur Faux peut être assimilée à la valeur numérique 0.
  • Ne pas oublier les parenthèses lorsqu'il y a un if :
 
Sélectionnez
if a > 0  // ne sera pas compilé !!!
   printf ("Valeur positive");
else
   printf ("Valeur négative");
  • au contraire, il faudrait écrire :
 
Sélectionnez
if (a > 0)
   printf ("Valeur positive");
else
   printf ("Valeur négative");
  • Différencier l'opérateur d'affectation =
  • Et l'opérateur de comparaison ==.

précédentsommairesuivant
L'analogie entre les opérateurs logiques d'une part et les opérations d'addition et de multiplication d'autre part n'est pas parfaite. Elle permet néanmoins de se faire une idée plus calculatoire du fonctionnement des opérateurs logiques.

  

Licence Creative Commons
Le contenu de cet article est rédigé par Eric Berthomier et Daniel Schang et est mis à disposition selon les termes de la Licence Creative Commons Attribution 3.0 non transposé.
Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright © 2013 Developpez.com.