Le expressions conditionnelles (également connues sous le nom de structures de contrôle de décision) telles que if, if else, switch, etc. sont utilisées à des fins de prise de décision dans les programmes C.
Ils sont également appelés déclarations de prise de décision et sont utilisés pour évaluer une ou plusieurs conditions et prendre la décision d'exécuter ou non un ensemble d'instructions. Ces déclarations de prise de décision dans les langages de programmation décident de la direction du flux d'exécution du programme.
Besoin d'instructions conditionnelles
Il arrive des situations dans la vie réelle où nous devons prendre certaines décisions et, sur la base de ces décisions, nous décidons quoi faire ensuite. Des situations similaires se produisent également en programmation où nous devons prendre certaines décisions et, sur la base de ces décisions, nous exécuterons le prochain bloc de code. Par exemple, en C, si x se produit, exécutez y, sinon exécutez z. Il peut également y avoir plusieurs conditions comme en C si x se produit, exécutez p, sinon si la condition y se produit, exécutez q, sinon exécutez r. Cette condition de C else-if est l'une des nombreuses façons d'importer plusieurs conditions.
Types d'instructions conditionnelles en C
Voici les déclarations de prise de décision disponibles en C :
- si déclaration
- Déclaration if-else
- Instruction if imbriquée
- si-sinon-si échelle
- Déclaration de commutation
- Opérateur conditionnel
- Déclarations de saut :
- casser
- continuer
- aller à
- retour
Discutons de chacun d’eux un par un.
1. si en C
Le si déclaration est la déclaration de prise de décision la plus simple. Il est utilisé pour décider si une certaine instruction ou un certain bloc d'instructions sera exécuté ou non, c'est-à-dire si une certaine condition est vraie, alors un bloc d'instructions est exécuté sinon non.
Syntaxe de l'instruction if
if ( condition ) { // Statements to execute if // condition is true }>
Ici le condition après l'évaluation sera vrai ou faux. L'instruction C if accepte les valeurs booléennes – si la valeur est vraie, elle exécutera le bloc d'instructions en dessous, sinon pas. Si nous ne fournissons pas les accolades '{' et '}' après if(condition), alors par défaut l'instruction if considérera la première instruction immédiatement en dessous comme étant à l'intérieur de son bloc.
Organigramme de l'instruction if

Diagramme de flux de l'instruction if
Exemple de si en C
C
arbre binaire vs bst
// C program to illustrate If statement> #include> > int> main()> {> > int> i = 10;> > > if> (i>15) {> > printf> (> '10 is greater than 15'> );> > }> > > printf> (> 'I am Not in if'> );> }> |
>
>Sortir
I am Not in if>
Comme la condition présente dans l'instruction if est fausse. Ainsi, le bloc situé sous l'instruction if n'est pas exécuté.
2. si-sinon en C
Le si L'instruction seule nous dit que si une condition est vraie, elle exécutera un bloc d'instructions et si la condition est fausse, elle ne le fera pas. Mais que se passe-t-il si nous voulons faire autre chose lorsque la condition est fausse ? Voici le C autre déclaration. Nous pouvons utiliser le autre déclaration avec le si instruction pour exécuter un bloc de code lorsque la condition est fausse. Le instruction if-else se compose de deux blocs, un pour la fausse expression et un pour la vraie expression.
Syntaxe de if else en C
if ( condition ) { // Executes this block if // condition is true } else { // Executes this block if // condition is false }>
Organigramme de l'instruction if-else

Diagramme de flux de if else
Exemple de if-else
C
// C program to illustrate If statement> #include> > int> main()> {> > int> i = 20;> > > if> (i <15) {> > > printf> (> 'i is smaller than 15'> );> > }> > else> {> > > printf> (> 'i is greater than 15'> );> > }> > return> 0;> }> |
>
>Sortir
i is greater than 15>
Le bloc de code suivant le autre L'instruction est exécutée comme la condition présente dans le si la déclaration est fausse.
3. If-else imbriqué dans C
Un if imbriqué dans C est une instruction if qui est la cible d'une autre instruction if. Les instructions if imbriquées signifient une instruction if dans une autre instruction if. Oui, C nous permet d'imbriquer des instructions if dans des instructions if, c'est-à-dire que nous pouvons placer une instruction if dans une autre instruction if.
Syntaxe de Nested if-else
if ( condition1 ) { // Executes when condition1 is true if ( condition2 ) { // Executes when condition2 is true } else { // Executes when condition2 is false }>
Organigramme de Nested if-else
Diagramme de flux de if-else imbriqué
Exemple de if-else imbriqué
C
// C program to illustrate nested-if statement> #include> > int> main()> {> > int> i = 10;> > > if> (i == 10) {> > // First if statement> > if> (i <15)> > printf> (> 'i is smaller than 15
'> );> > > // Nested - if statement> > // Will only be executed if statement above> > // is true> > if> (i <12)> > printf> (> 'i is smaller than 12 too
'> );> > else> > printf> (> 'i is greater than 15'> );> > }> > > return> 0;> }> |
>
définir l'intervalle javascript
>Sortir
i is smaller than 15 i is smaller than 12 too>
4. if-else-if Échelle en C
Le sinon si déclarations sont utilisés lorsque l'utilisateur doit choisir parmi plusieurs options. Les instructions C if sont exécutées de haut en bas. Dès qu'une des conditions contrôlant le if est vraie, l'instruction associée à ce if est exécutée et le reste de l'échelle C else-if est contourné. Si aucune des conditions n’est vraie, alors l’instruction else finale sera exécutée. L'échelle if-else-if est similaire à l'instruction switch.
Syntaxe de l'échelle if-else-if
if ( condition ) statement; else if ( condition ) statement; . . else statement;>
Organigramme de l'échelle if-else-if

Diagramme de flux de if-else-if
Exemple d'échelle if-else-if
C
// C program to illustrate nested-if statement> #include> > int> main()> {> > int> i = 20;> > > if> (i == 10)> > printf> (> 'i is 10'> );> > else> if> (i == 15)> > printf> (> 'i is 15'> );> > else> if> (i == 20)> > printf> (> 'i is 20'> );> > else> > printf> (> 'i is not present'> );> }> |
>
>Sortir
i is 20>
5. switch Instruction en C
Le déclaration de changement de cas est une alternative à l'échelle if else if qui peut être utilisée pour exécuter le code conditionnel en fonction de la valeur de la variable spécifiée dans l'instruction switch. Le bloc switch se compose de cas à exécuter en fonction de la valeur de la variable switch.
Syntaxe de switch
switch ( expression ) { case value1: statements; case value2: statements; .... .... .... default: statements; }>
Note: L’expression switch doit être évaluée comme un entier ou un caractère. Il ne peut évaluer aucun autre type de données.
Organigramme du commutateur

Organigramme du commutateur en C
Exemple d'instruction switch
C
// C Program to illustrate the use of switch statement> #include> > int> main()> {> > // variable to be used in switch statement> > int> var = 2;> > > // declaring switch cases> > switch> (var) {> > case> 1:> > printf> (> 'Case 1 is executed'> );> > break> ;> > case> 2:> > printf> (> 'Case 2 is executed'> );> > break> ;> > default> :> > printf> (> 'Default Case is executed'> );> > break> ;> > }> > > return> 0;> }> |
Shreya Ghoshal, premier mari
>
>Sortir
Case 2 is executed>
6. Opérateur conditionnel en C
Le opérateur conditionnel est utilisé pour ajouter du code conditionnel dans notre programme. C'est similaire à l'instruction if-else. Il est également connu sous le nom d’opérateur ternaire car il fonctionne sur trois opérandes.
Syntaxe de l'opérateur conditionnel
( condition ) ? [true_statements] : [false_statements] ;>
Organigramme de l'opérateur conditionnel

Diagramme de flux de l'opérateur conditionnel
Exemple d'opérateur conditionnel
C
// C Program to illustrate the use of conditional operator> #include> > // driver code> int> main()> {> > > int> var;> > int> flag = 0;> > > // using conditional operator to assign the value to var> > // according to the value of flag> > var = flag == 0 ? 25 : -25;> > printf> (> 'Value of var when flag is 0: %d
'> , var);> > > // changing the value of flag> > flag = 1;> > // again assigning the value to var using same statement> > var = flag == 0 ? 25 : -25;> > printf> (> 'Value of var when flag is NOT 0: %d'> , var);> > > return> 0;> }> |
>
>Sortir
Value of var when flag is 0: 25 Value of var when flag is NOT 0: -25>
7. Sauter les instructions en C
Ces instructions sont utilisées en C pour le flux de contrôle inconditionnel à travers les fonctions d'un programme. Ils prennent en charge quatre types d'instructions de saut :
UN) casser
Cette instruction de contrôle de boucle est utilisée pour terminer la boucle. Aussi tôt que le casser L'instruction est rencontrée à l'intérieur d'une boucle, les itérations de la boucle s'arrêtent là et le contrôle revient immédiatement de la boucle à la première instruction après la boucle.
Syntaxe de pause
break;>
Fondamentalement, les instructions break sont utilisées dans des situations où nous ne sommes pas sûrs du nombre réel d'itérations de la boucle ou si nous souhaitons terminer la boucle en fonction d'une condition.

Exemple de pause
C
// C program to illustrate> // to show usage of break> // statement> #include> > void> findElement(> int> arr[],> int> size,> int> key)> {> > // loop to traverse array and search for key> > for> (> int> i = 0; i if (arr[i] == key) { printf('Element found at position: %d', (i + 1)); break; } } } int main() { int arr[] = { 1, 2, 3, 4, 5, 6 }; // no of elements int n = 6; // key to be searched int key = 3; // Calling function to find the key findElement(arr, n, key); return 0; }> |
>
>Sortir
Element found at position: 3>
B) continuer
Cette instruction de contrôle de boucle est similaire à l'instruction break. Le continuer déclaration est opposé à celui de la pause déclaration , au lieu de terminer la boucle, il force l'exécution de la prochaine itération de la boucle.
Comme son nom l'indique, l'instruction continue force la boucle à continuer ou à exécuter l'itération suivante. Lorsque l'instruction continue est exécutée dans la boucle, le code à l'intérieur de la boucle suivant l'instruction continue sera ignoré et la prochaine itération de la boucle commencera.
Syntaxe de continuer
continue;>
Organigramme de Continuer
Diagramme de flux de l'instruction C continue
Exemple de continuer
C
langage groovy
// C program to explain the use> // of continue statement> #include> > int> main()> {> > // loop from 1 to 10> > for> (> int> i = 1; i <= 10; i++) {> > > // If i is equals to 6,> > // continue to next iteration> > // without printing> > if> (i == 6)> > continue> ;> > > else> > // otherwise print the value of i> > printf> (> '%d '> , i);> > }> > > return> 0;> }> |
>
>Sortir
1 2 3 4 5 7 8 9 10>
Si vous créez une variable dans if-else en C, elle sera locale à ce bloc if/else uniquement. Vous pouvez utiliser des variables globales dans le bloc if/else. Si le nom de la variable que vous avez créée dans if/else est le même que celui de n'importe quelle variable globale, alors la priorité sera donnée à la « variable locale ».
C
#include> > int> main()> {> > > int> gfg = 0;> // local variable for main> > printf> (> 'Before if-else block %d
'> , gfg);> > if> (1) {> > int> gfg = 100;> // new local variable of if block> > printf> (> 'if block %d
'> , gfg);> > }> > printf> (> 'After if block %d'> , gfg);> > return> 0;> }> |
>
>Sortir
Before if-else block 0 if block 100 After if block 0>
C) aller à
Le aller à la déclaration en C, également appelée instruction de saut inconditionnel, peut être utilisée pour passer d'un point à un autre au sein d'une fonction.
Syntaxe de goto
Syntax1 | Syntax2 ---------------------------- goto label; | label: . | . . | . . | . label: | goto label;>
Dans la syntaxe ci-dessus, la première ligne indique au compilateur d'accéder ou de passer à l'instruction marquée comme étiquette. Ici, une étiquette est un identifiant défini par l'utilisateur qui indique l'instruction cible. L'instruction immédiatement suivie après « label : » est l'instruction de destination. Le « label : » peut également apparaître avant l’instruction « goto label ; » dans la syntaxe ci-dessus.
Organigramme de l'instruction goto
Exemples de goto
C
// C program to print numbers> // from 1 to 10 using goto> // statement> #include> > // function to print numbers from 1 to 10> void> printNumbers()> {> > int> n = 1;> label:> > printf> (> '%d '> , n);> > n++;> > if> (n <= 10)> > goto> label;> }> > // Driver program to test above function> int> main()> {> > printNumbers();> > return> 0;> }> |
>
>Sortir
1 2 3 4 5 6 7 8 9 10>
D) retour
Le retour en C renvoie le flux de l'exécution à la fonction à partir de laquelle elle est appelée. Cette instruction ne nécessite obligatoirement aucune instruction conditionnelle. Dès que l'instruction est exécutée, le déroulement du programme s'arrête immédiatement et rend le contrôle d'où il a été appelé. L'instruction return peut ou non renvoyer quoi que ce soit pour une fonction void, mais pour une fonction non-void, une valeur de retour doit être renvoyée.
Organigramme de retour

Diagramme de flux de retour
Syntaxe de retour
return [expression] ;>
Exemple de retour
C
// C code to illustrate return> // statement> #include> > // non-void return type> // function to calculate sum> int> SUM(> int> a,> int> b)> {> > int> s1 = a + b;> > return> s1;> }> > // returns void> // function to print> void> Print(> int> s2)> {> > printf> (> 'The sum is %d'> , s2);> > return> ;> }> > int> main()> {> > int> num1 = 10;> > int> num2 = 10;> > int> sum_of = SUM(num1, num2);> > Print(sum_of);> > return> 0;> }> |
python // opérateur
>
>Sortir
The sum is 20>