6. Instructions de contrôle (les conditions)
 |
| Instructions de contrôle - SAGProfProg - LANGAGE C - Programmation, Développement web, Développement d'application, Génie Logiciel, Langage de programmation, Application web, Tutos, Informatique, Système d'information, Administration d'application |
Si sinon Déclaration
L'instruction if-else en C est utilisée pour effectuer les opérations en fonction d'une condition spécifique. Les opérations spécifiées dans le bloc if sont exécutées si et seulement si la condition donnée est vraie.
Les variantes suivantes de l'instruction if en langage C sont les suivantes.
- Si déclaration
- Instruction if-else
- Si sinon-si échelle
- Imbriqué si
Si déclaration
L'instruction if est utilisée pour vérifier une condition donnée et effectuer certaines opérations en fonction de l'exactitude de cette condition. Il est principalement utilisé dans le scénario où nous devons effectuer les différentes opérations pour les différentes conditions. La syntaxe de l'instruction if est donnée ci-dessous.
if(expression){
//code à exécuter
}
Voyons un exemple simple d'instruction if en langage C.
#include<stdio.h>
int main(){
int nombre=0 ;
printf("Entrez un nombre :");
scanf("%d",&nombre);
if(nombre%2==0){
printf("%d est un nombre pair",nombre);
}
return 0 ;
}
Production
Programme pour trouver le plus grand nombre des trois.
#include <stdio.h>
int main()
{
int a, b, c ;
printf("Entrez trois nombres?");
scanf("%d %d %d",&a,&b,&c);
if(a>b && a>c)
{
printf("%d est le plus grand",a);
}
if(b>a && b > c)
{
printf("%d est le plus grand",b);
}
if(c>a && c>b)
{
printf("%d est le plus grand",c);
}
if(a == b && a == c)
{
printf("Tous sont égaux");
}
}
Production
Instruction Si-sinon
L'instruction if-else est utilisée pour effectuer deux opérations pour une seule condition. L'instruction if-else est une extension de l'instruction if à l'aide de laquelle nous pouvons effectuer deux opérations différentes, c'est-à-dire que l'une concerne l'exactitude de cette condition et l'autre l'inexactitude de la condition. Ici, nous devons remarquer que les blocs if et else ne peuvent pas être exécutés simultanément. L'utilisation de l'instruction if-else est toujours préférable car elle invoque toujours un cas contraire avec chaque condition if. La syntaxe de l'instruction if-else est donnée ci-dessous.
if(expression){
//code à exécuter si la condition est vraie
}else{
//code à exécuter si la condition est fausse
}
Voyons l'exemple simple pour vérifier si un nombre est pair ou impair en utilisant l'instruction if-else en langage C.
#include<stdio.h>
int main(){
int nombre=0 ;
printf("entrez un nombre :");
scanf("%d",&nombre);
if(nombre%2==0){
printf("%d est un nombre pair",nombre);
}
else{
printf("%d est un nombre impair",nombre);
}
return 0 ;
}
Production
Programme pour vérifier si une personne a le droit de voter ou non.
#include <stdio.h>
int main()
{
int age ;
printf("Entrez votre age?");
scanf("%d",&age);
if(age>=18)
{
printf("Vous avez le droit de voter...");
}
else
{
printf("Désolé... vous ne pouvez pas voter");
}
}
Production
Si sinon si
L'instruction en échelle if-else-if est une extension de l'instruction if-else. Il est utilisé dans le scénario où il y a plusieurs cas à effectuer pour différentes conditions. Dans l'instruction en échelle if-else-if, si une condition est vraie, les instructions définies dans le bloc if seront exécutées, sinon si une autre condition est vraie, les instructions définies dans le bloc else-if seront exécutées, à la dernière si aucune des conditions n'est vraie, les instructions définies dans le bloc else seront exécutées. Il existe plusieurs blocs else-if possibles. C'est similaire à l'instruction switch case où la valeur par défaut est exécutée au lieu du bloc else si aucun des cas ne correspond.
if(condition1){
//code à exécuter si condition1 est vraie
}
else if(condition2){
//code à exécuter si condition2 est vraie
}
else if(condition3){
//code à exécuter si condition3 est vraie
}
...
else{
//code à exécuter si toutes les conditions sont fausses
}
L'exemple d'une instruction if-else-if en langage C est donné ci-dessous.
#include<stdio.h>
int main(){
int nombre=0 ;
printf("entrez un nombre :");
scanf("%d",&nombre);
if(nombre==10){
printf("le nombre est egal a 10");
}
else if(nombre==50){
printf("le nombre est egal a 50");
}
else if(nombre==100){
printf("le nombre est egal a 100");
}
else{
printf("le nombre n'est pas egal a 10, 50 ou 100");
}
return 0 ;
}
Production
Programme pour calculer la note de l'étudiant en fonction des notes spécifiées.
#include <stdio.h>
int main()
{
int note;
printf("Entrez vos notes?");
scanf("%d",¬e);
if(note > 85 && note <= 100)
{
printf("Félicitations ! vous avez obtenu la note A ...");
}
else if (note > 60 && note <= 85)
{
printf("Vous avez obtenu la note B + ...");
}
else if (note > 40 && note <= 60)
{
printf("Vous avez obtenu la note B...");
}
else if(note > 30 && note <= 40)
{
printf("Vous avez obtenu la note C...");
}
else
{
printf("Désolé, vous avez échoué...");
}
}
Production
Instruction de commutation(switch)
L'instruction switch en C est une alternative à l'instruction échelle if-else-if qui nous permet d'exécuter plusieurs opérations pour les différentes valeurs possibles d'une seule variable appelée variable switch. Ici, nous pouvons définir diverses déclarations dans les multiples cas pour les différentes valeurs d'une même variable.
La syntaxe de l'instruction switch en langage c est donnée ci-dessous :
switch(expression){
case valeur1 :
//code à exécuter ;
break; //optionnel
case valeur2 :
//code à exécuter ;
break; //optionnel
......
default:
code à exécuter si tous les cas ne correspondent pas ;
}
Règles pour l'instruction switch en langage C
1) L'expression switch doit être de type entier ou caractère.
2) La valeur de casse doit être un nombre entier ou une constante de caractère.
3) La valeur case ne peut être utilisée qu'à l'intérieur de l'instruction switch.
4) L'instruction break dans le cas du commutateur n'est pas indispensable. C'est facultatif. S'il n'y a pas d'instruction break trouvée dans le cas, tous les cas seront exécutés après le cas correspondant. C'est ce qu'on appelle l'état de basculement de l'instruction C switch.
Essayons de le comprendre par les exemples. Nous supposons qu'il existe des variables suivantes.
int x, y, z ;
char a,b ;
float f ;
|
Switch valide |
Switch invalide |
Case valide |
Case invalide |
|
switch(x) |
switch(f) |
case 3; |
case 2.5; |
|
switch(x>y) |
switch(x+2.5) |
case 'a'; |
case x; |
|
switch(a+b-2) |
case 1+2; |
case x+2; |
|
|
switch(func(x,y)) |
case 'x'>'y'; |
case 1,2,3; |
Fonctionnement de l'instruction switch case
L'expression entière spécifiée dans l'instruction switch est d'abord évaluée. Cette valeur est alors mise en correspondance une par une avec les valeurs constantes données dans les différents cas. Si une correspondance est trouvée, alors toutes les déclarations spécifiées dans ce cas sont exécutées avec tous les cas présents après ce cas, y compris la déclaration par défaut. Il n'y a pas deux cas qui peuvent avoir des valeurs similaires. Si le cas correspondant contient une instruction break, tous les cas présents après celui-ci seront ignorés et le contrôle sortira du commutateur. Sinon, tous les cas suivant le cas correspondant seront exécutés.
Voyons un exemple simple d'instruction de changement de langage c.
#include<stdio.h>
int main(){
int nombre=0 ;
printf("entrez un nombre :");
scanf("%d",&nombre);
switch(nombre) {
case 10 :
printf("le nombre est egal a 10");
break;
case 50 :
printf("le nombre est egal a 50");
break;
case 100 :
printf("le nombre est egal a 100");
break;
default:
printf("le nombre n'est pas egal a 10, 50 ou 100");
}
return 0 ;
}
Production
Switch case exemple 2
#include <stdio.h>
int main()
{
int x = 10, y = 5 ;
switch(x>y && x+y>0)
{
case 1:
printf("salut");
break;
case 0 :
printf("au revoir");
break;
default:
printf(" Bonjour au revoir ");
}
}
Production
L'instruction Switch est tombée dans l'eau
En langage C, l'instruction switch est fall through ; cela signifie que si vous n'utilisez pas d'instruction break dans le cas du commutateur, tous les cas après le cas correspondant seront exécutés.
Essayons de comprendre la chute à travers l'état de l'instruction switch par l'exemple donné ci-dessous.
#include<stdio.h>
int main(){
int nombre=0 ;
printf("entrez un nombre :");
scanf("%d",&nombre);
switch(nombre) {
case 10 :
printf("le nombre est egal a 10\n");
case 50 :
printf("le nombre est egal a 50\n");
case 100 :
printf("le nombre est egal a 100\n");
default:
printf("le nombre n'est pas egal a 10, 50 ou 100");
}
return 0 ;
}
Production
Instruction de cas de commutation (switch case) imbriquée
Nous pouvons utiliser autant d'instructions switch que nous le voulons dans une instruction switch. Ce type d'instructions est appelé instructions de cas de commutation imbriquées. Prenons l'exemple suivant.
#include <stdio.h>
int main () {
int i = 10 ;
int j = 20 ;
switch(i) {
case 10 :
printf("la valeur de i evaluee dans le commutateur externe : %d\n",i);
case 20 :
switch(j) {
case 20 :
printf("La valeur de j evaluee dans le commutateur imbrique : %d\n",j);
}
}
printf("La valeur exacte de i est : %d\n", i );
printf("La valeur exacte de j est : %d\n", j );
return 0 ;
}
Production
Aucun commentaire