Instructions de contrôle en C, Partie 1

Bienvenue dans la prochaine tranche de notre série, Principes fondamentaux de C.

Les instructions de contrôle nous permettent de spécifier le flux de contrôle du programme; c’est-à-dire l’ordre dans lequel les instructions d’un programme doivent être exécutées. Ils permettent de prendre des décisions, d’effectuer des tâches à plusieurs reprises ou de passer d’une section de code à une autre.

Il existe quatre types d’instructions de contrôle en C:

1. Instructions de prise de décision
2. Instructions de sélection
3. Instructions d’itération
4. Instructions de saut

Instruction de prise de décision : l’instruction if-else

L’instruction if-else est utilisée pour effectuer un test logique, puis prendre l’une des deux actions possibles en fonction de le résultat du test (c’est-à-dire si le résultat est vrai ou faux).

Syntaxe:

if (condition){ statements} else{ statements}

Si la condition spécifiée dans l’instruction if est évaluée à true, les instructions à l’intérieur du bloc if sont exécutées, puis le contrôle est transféré à l’instruction immédiatement après le bloc if. Même si la condition est fausse et qu’aucun bloc else n’est présent, le contrôle est transféré à l’instruction immédiatement après le bloc if.

La partie else n’est requise que si une certaine séquence d’instructions doit être exécutée si la condition est évaluée à false. Il est important de noter que la condition est toujours spécifiée entre parenthèses et qu’il est recommandé de placer les instructions dans le bloc if ou dans le bloc else entre accolades, qu’il s’agisse d’une instruction unique ou d’une instruction composée.

Le programme suivant vérifie si le nombre saisi est positif ou négatif.

#include<stdio.h>int main( ) { int a; printf("n Enter a number:"); scanf("%d", &a); if(a>0) { printf( "n The number %d is positive.",a); } else { printf("n The number %d is negative.",a); } return 0; }

Le programme suivant compare deux chaînes pour vérifier si elles sont égales ou non.

#include <stdio.h>#include <string.h>int main( ) { char a , b; printf("n Enter the first string:"); scanf("%s",a); printf("n Enter the second string:"); scanf("%s",b); if((strcmp(a,b)==0)) { printf("nStrings are the same"); } else { printf("nStrings are different"); } return 0; }

Le programme ci-dessus compare deux chaînes pour vérifier si elles sont identiques ou non. La fonction strcmp est utilisée à cet effet. Il est déclaré dans le fichier string.h comme:

int strcmp(const char *s1, const char *s2);

Il compare la chaîne pointée par s1 à la chaîne pointée par s2. La fonction strcmp renvoie un entier supérieur, égal ou inférieur à zéro, en conséquence, car la chaîne pointée par s1 est supérieure, égale ou inférieure à la chaîne pointée par s2.

Par conséquent, dans le programme ci-dessus, si les deux chaînes a et b sont égales, la fonction strcmp doit renvoyer un 0. S’il renvoie un 0, les chaînes sont les mêmes; sinon elles sont différentes.

Instructions imbriquées if et if-else

Il est également possible d’intégrer ou d’imbriquer les instructions if-else les unes dans les autres. L’imbrication est utile dans les situations où l’un des différents plans d’action doit être sélectionné.

Le format général d’une instruction if-else imbriquée est:

if(condition1){// statement(s);}else if(condition2){//statement(s);}....else if (conditionN){//statement(s);}else{//statement(s);}

Ce qui précède est également appelé l’échelle if-else. Lors de l’exécution d’une instruction if-else imbriquée, dès qu’une condition est rencontrée qui s’évalue à true, les instructions associées à ce bloc if particulier seront exécutées et le reste des instructions if-else imbriquées sera contourné. Si aucune des conditions n’est vraie, soit le dernier bloc else est exécuté, soit si le bloc else est absent, le contrôle est transféré à l’instruction suivante présente immédiatement après l’échelle else-if.

Le programme suivant utilise l’instruction if-else imbriquée pour trouver le plus grand des trois nombres.

#include<stdio.h>int main( ) { int a, b,c; a=6,b= 5, c=10; if(a>b) { if(b>c) { printf("nGreatest is: " , a); } else if(c>a) { printf("nGreatest is: ", c); } } else if(b>c) //outermost if-else block { printf("nGreatest is: " , b); } else { printf( "nGreatest is: " , c); } return 0; }

Le programme ci-dessus compare trois quantités entières et imprime la plus grande. La première instruction if compare les valeurs de a et b. Si a>b vaut true, le contrôle du programme est transféré à l’instruction if-else imbriquée dans le bloc if, où b est comparé à c. Si b>c est également vrai, la valeur de a est imprimée ; sinon les valeurs de c et a sont comparées et si c>a est vrai, la valeur de c est imprimée. Après cela, le reste de l’échelle if-else est contourné.

Cependant, si la première condition a>b est fausse, le contrôle est directement transféré au bloc else-if le plus à l’extérieur, où la valeur de b est comparée à c (car a n’est pas la plus grande). Si b>c est vrai, la valeur de b est imprimée sinon la valeur de c est imprimée. Notez l’imbrication, l’utilisation d’accolades et l’indentation. Tout cela est nécessaire pour maintenir la clarté.

Instruction de sélection: l’instruction switch-case

Une instruction switch est utilisée pour des sélections à plusieurs voies qui se ramifieront en différents segments de code en fonction de la valeur d’une variable ou d’une expression. Cette expression ou variable doit être de type entier.

Syntaxe:

switch (expression){ case value1: code segment1; break; case value2: code segment2; break;... case valueN: code segmentN; break; default: default code segment;}

La valeur de cette expression est générée pendant l’exécution du programme ou lue en tant qu’entrée utilisateur. La casse dont la valeur est la même que celle de l’expression est sélectionnée et exécutée. L’étiquette par défaut facultative est utilisée pour spécifier le segment de code à exécuter lorsque la valeur de l’expression ne correspond à aucune des valeurs de casse.

La déclaration break est présente à la fin de chaque cas. Si ce n’était pas le cas, l’exécution se poursuivrait dans le segment de code de la casse suivante sans même vérifier la valeur de la casse. Par exemple, supposons qu’une instruction switch ait cinq cas et que la valeur du troisième cas corresponde à la valeur de l’expression. Si aucune instruction break n’était présente à la fin du troisième cas, tous les cas après le cas 3 seraient également exécutés avec le cas 3. Si break est présent, seul le cas requis est sélectionné et exécuté ; après quoi le contrôle est transféré à l’instruction suivante immédiatement après l’instruction switch. Il n’y a pas break après default car après le cas par défaut, le contrôle sera de toute façon transféré à l’instruction suivante immédiatement après le commutateur.

Exemple : un programme pour imprimer le jour de la semaine.

#include<stdio.h>int main( ) { int day; printf("nEnter the number of the day:"); scanf("%d",&day); switch(day) { case 1: printf("Sunday"); break; case 2: printf("Monday"); break; case 3: printf("Tuesday"); break; case 4: printf("Wednesday"); break; case 5: printf("Thursday"); break; case 6: printf("Friday"); break; case 7: printf("Saturday"); break; default: printf("Invalid choice"); } return 0; }

C’est un programme très basique qui explique le fonctionnement de la construction du boîtier de commutation. En fonction du numéro saisi par l’utilisateur, la casse appropriée est sélectionnée et exécutée. Par exemple, si l’entrée utilisateur est 5, le cas 5 sera exécuté. L’instruction break présente dans le cas 5 mettra en pause l’exécution de l’instruction switch après le cas 5 et le contrôle sera transféré à l’instruction suivante après le commutateur, qui est:

return 0;

Il est également possible d’intégrer des instructions composées dans le cas d’une instruction switch. Ces énoncés composés peuvent contenir des structures de contrôle. Ainsi, il est également possible d’avoir un commutateur imbriqué en l’intégrant dans un boîtier.

Tous les programmes écrits à l’aide de l’instruction switch-case peuvent également être écrits à l’aide de l’instruction if-else. Cependant, il est judicieux d’utiliser l’instruction if lorsque vous devez prendre des mesures après avoir évalué une condition simple ou complexe pouvant impliquer une combinaison d’expressions relationnelles et logiques (par exemple, (if((a!=0)&&(b>5))).

Si vous devez sélectionner parmi un grand groupe de valeurs, une instruction switch s’exécutera beaucoup plus rapidement qu’un ensemble d’fs imbriqués. Le commutateur diffère de l’if dans ce commutateur ne peut tester que l’égalité, alors que if peut évaluer tout type d’expression booléenne.

L’instruction switch doit être utilisée lorsque l’on doit faire un choix parmi un ensemble de choix donné. L’instruction switch case est généralement utilisée dans les applications basées sur des menus. L’utilisation la plus courante d’une instruction de cas de commutation est dans le traitement des données ou le traitement des fichiers. La plupart du traitement des fichiers implique les fonctions courantes: création d’un fichier, ajout d’enregistrements, suppression d’enregistrements, mise à jour d’enregistrements, impression du fichier entier ou de certains enregistrements sélectifs. Le programme suivant donne une idée de la façon dont l’instruction switch case peut être utilisée dans le traitement des données. Cela n’implique pas le code pour le traitement des fichiers car nous ne pouvons discuter du traitement des fichiers en C qu’après avoir appris des concepts avancés tels que les pointeurs, les structures et les unions.

Exemple : Une instruction de cas de commutation utilisée dans le traitement de fichiers de données.

#include<stdio.h>int main() { //create file &set file pointer . int choice; printf("n Please select from the following options:"); printf("n 1. Add a record at the end of the file."); printf("n 2. Add a record at the beginning of the file:"); printf("n 3. Add a record after a particular record:"; printf("nPlease enter your choice:(1/2/3)?"); scanf("%d",&choice); switch(choice) { case 1: //code to add record at the end of the file break; case 2: //code to add record at the beginning of the file break; case 3: //code to add record after a particular record break; default: printf("n Wrong Choice"); } return 0; }

L’exemple ci-dessus de cas de commutation implique généralement l’imbrication de la construction de cas de commutation dans une construction d’itération comme do-while. Dans notre article nex, nous discuterons de ces instructions d’itération.