Le C en 20 heures

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.

É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 = kitxmlcodeinlinelatexdvp\sqrt{a^2+b^2}finkitxmlcodeinlinelatexdvp
où 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>)

a² peut s'obtenir par a*a.

 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 :

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.

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

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 :

si (je travaille) {
   alors je progresserai
}
sinon {
   je stagnerai
}

Enfin, le programme en Langage C ressemblera à ceci :

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.

Ils servent à comparer deux nombres entre eux : 

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

#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;
}

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

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

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 : 

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) : 

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

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 */

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 : 

Vous verrez souvent ce type de code écrit :

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

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

Ce qui donne en Langage C :

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) !!!

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

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

/* 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 !

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.");

 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 :

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

 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.

 Corrigé de l'exercice n°4.1 — Pythagore

#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;
}

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

#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;
}

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

#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;
}

• 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 :

if a > 0  // ne sera pas compilé !!!
   printf ("Valeur positive");
else
   printf ("Valeur négative");

• au contraire, il faudrait écrire :

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

• Différencier l'opérateur d'affectation =
• Et l'opérateur de comparaison ==.