C Language
Relevés de sélection

if () Déclarations

L'un des moyens les plus simples de contrôler le déroulement du programme consiste à utiliser les instructions de sélection if . Si un bloc de code doit être exécuté ou ne pas être exécuté peut être décidé par cette instruction.

La syntaxe de if instruction de sélection dans C peut être la suivante:

if(cond) 
{
  statement(s);  /*to be executed, on condition being true*/
}

Par exemple,

if (a > 1) {
    puts("a is larger than 1");
}

Où a > 1 est une condition qui doit être évaluée à true pour exécuter les instructions dans le bloc if . Dans cet exemple, "a est supérieur à 1" n'est imprimé que si a > 1 est vrai.

if instructions de sélection peuvent omettre les accolades { et } s'il n'y a qu'une seule instruction dans le bloc. L'exemple ci-dessus peut être réécrit pour

if (a > 1)
    puts("a is larger than 1");

Cependant, pour l'exécution de plusieurs instructions dans un bloc, les accolades doivent être utilisées.

La condition pour if peut inclure plusieurs expressions. if ne réalisera l'action que si le résultat final de l'expression est vrai.

Par exemple

if ((a > 1) && (b > 1)) {
    puts("a is larger than 1");
    a++;
}

n'exécutera le printf et a++ si les deux a et b sont supérieurs à 1 .

if () ... else instructions et syntaxe

Alors que if effectue une action uniquement lorsque sa condition est évaluée à true , if / else vous permet de spécifier les différentes actions lorsque la condition est true et que la condition est false .

Exemple:

if (a > 1)
    puts("a is larger than 1");
else 
    puts("a is not larger than 1");

Tout comme l'instruction if , lorsque le bloc if ou else se compose d'une seule instruction, les accolades peuvent être omises (mais cela n'est pas recommandé car cela peut facilement introduire des problèmes involontairement). Cependant, s'il y a plus d'une instruction dans le bloc if ou else , les accolades doivent être utilisées sur ce bloc particulier.

if (a > 1) 
{
    puts("a is larger than 1");
    a--;
}
else 
{
    puts("a is not larger than 1");
    a++;
}

switch instructions ()

switch instructions switch sont utiles lorsque vous souhaitez que votre programme effectue de nombreuses opérations différentes en fonction de la valeur d'une variable de test particulière.

Voici un exemple d'utilisation de l'instruction switch :

int a = 1;

switch (a) {
case 1:
    puts("a is 1");
    break;
case 2:
    puts("a is 2");
    break;
default:
    puts("a is neither 1 nor 2");
    break;
}

Cet exemple est équivalent à

int a = 1;

if (a == 1) {
    puts("a is 1");
} else if (a == 2) {
    puts("a is 2");
} else {
    puts("a is neither 1 nor 2");
}

Si la valeur de a est 1 lorsque l'instruction switch est utilisée, a is 1 sera imprimé. Si la valeur de a est 2 alors, a is 2 sera imprimé. Sinon, a is neither 1 nor 2 sera imprimé.

case n: est utilisé pour décrire l'endroit où le flux d'exécution interviendra lorsque la valeur transmise à l'instruction switch est n . n doit être une constante à la compilation et le même n peut exister au plus une fois dans une instruction de switch .

default: est utilisé pour décrire cela lorsque la valeur ne correspond à aucun des choix pour le case n: Il est recommandé d'inclure un cas default dans chaque instruction de commutateur pour détecter un comportement inattendu.

Une break; déclaration est nécessaire pour sauter hors du bloc de switch .

Remarque: Si vous oubliez accidentellement d'ajouter une break après la fin d'un case , le compilateur suppose que vous avez l' intention de « passer » et toutes les déclarations de cas suivantes, le cas échéant, seront exécutées (sauf si une instruction break se trouve dans n'importe lequel des cas suivants), que la déclaration de cas suivante corresponde ou non. Cette propriété particulière est utilisée pour implémenter le périphérique de Duff . Ce comportement est souvent considéré comme une faille dans la spécification du langage C.

Voici un exemple qui montre les effets de l’absence de break; :

int a = 1;

switch (a) {
case 1:
case 2:
    puts("a is 1 or 2");
case 3:
    puts("a is 1, 2 or 3");
    break;
default:
    puts("a is neither 1, 2 nor 3");
    break;
}

Lorsque la valeur de a est 1 ou 2, a is 1 or 2 et a is 1, 2 or 3 seront tous deux imprimés. Quand a est 3, seulement a is 1, 2 or 3 sera imprimé. Sinon, a is neither 1, 2 nor 3 sera imprimé.

Notez que le cas default n'est pas nécessaire, surtout lorsque le jeu de valeurs que vous obtenez dans le switch est terminé et connu à la compilation.

Le meilleur exemple consiste à utiliser un switch sur un enum .

enum msg_type { ACK, PING, ERROR };
void f(enum msg_type t)
{
  switch (t) {
  case ACK:
    // do nothing
    break;
  case PING:
    // do something
    break;
  case ERROR:
    // do something else
    break;
  }
}

Cela présente plusieurs avantages:

• la plupart des compilateurs signaleront un avertissement si vous ne gérez pas une valeur (cela ne serait pas signalé si un cas default était présent)
• pour la même raison, si vous ajoutez une nouvelle valeur à l' enum , vous serez informé de tous les endroits où vous avez oublié de gérer la nouvelle valeur (avec un cas default , vous devrez explorer manuellement votre code pour rechercher ces cas)
• Le lecteur n'a pas besoin de déterminer "ce qui est masqué par la default: par default: ", s'il existe d'autres valeurs de enum ou s'il s'agit d'une protection pour "juste au cas où". Et s'il y a d'autres valeurs d' enum , le codeur a-t-il intentionnellement utilisé le cas default pour eux ou y a-t-il un bogue qui a été introduit lorsqu'il a ajouté la valeur?
• gérer chaque valeur d' enum rend le code explicite, car vous ne pouvez pas vous cacher derrière un caractère générique, vous devez gérer explicitement chacun d'eux.

Néanmoins, vous ne pouvez pas empêcher quelqu'un d'écrire du code maléfique comme:

enum msg_type t = (enum msg_type)666; // I'm evil

Ainsi, vous pouvez ajouter une vérification supplémentaire avant votre commutateur pour le détecter, si vous en avez vraiment besoin.

void f(enum msg_type t)
{
   if (!is_msg_type_valid(t)) {
      // Handle this unlikely error
   }

   switch(t) { 
    // Same code than before
   }
}

if () ... else Ladder Chaînage deux ou plus if () ... else instructions

Alors que l'instruction if ()... else permet de définir un seul comportement (par défaut) qui se produit lorsque la condition dans if () n'est pas remplie, chaîner deux ou plusieurs if () ... else permet de définir un couple plus de comportements avant d' aller à la dernière else branche agissant comme « par défaut », le cas échéant.

Exemple:

int a = ... /* initialise to some value. */

if (a >= 1) 
{
    printf("a is greater than or equals 1.\n");
} 
else if (a == 0) //we already know that a is smaller than 1
{
    printf("a equals 0.\n");
}
else /* a is smaller than 1 and not equals 0, hence: */
{ 
    printf("a is negative.\n");
}

Imbriqué if () ... else VS if () .. sinon Ladder

Imbriquées if()...else instructions prennent plus de temps d’exécution (elles sont plus lentes) que les if()...else parce que les instructions if()...else vérifient toutes les instructions conditionnelles internes L'instruction conditionnelle if() est satisfaite, alors que l'échelle if()..else arrête le test de condition une fois que les instructions conditionnelles if() ou else if() sont vraies.

Une échelle if()...else :

#include <stdio.h>

int main(int argc, char *argv[])
{
  int a, b, c;
  printf("\nEnter Three numbers = ");
  scanf("%d%d%d", &a, &b, &c);
  if ((a < b) && (a < c))
  {
    printf("\na = %d is the smallest.", a);
  }
  else if ((b < a) && (b < c))
  {
    printf("\nb = %d is the smallest.", b);
  }
  else if ((c < a) && (c < b))
  {
    printf("\nc = %d is the smallest.", c);
  }
  else
  {
    printf("\nImprove your coding logic");
  }
  return 0;
}

Est-ce, dans le cas général, considéré comme meilleur que l'équivalent imbriqué if()...else :

#include <stdio.h>

int main(int argc, char *argv[])
{
  int a, b, c;
  printf("\nEnter Three numbers = ");
  scanf("%d%d%d", &a, &b, &c);
  if (a < b)
  {
    if (a < c)
      {
        printf("\na = %d is the smallest.", a);
      }
    else
      {
        printf("\nc = %d is the smallest.", c);
      }
  }
  else
  {
    if(b < c)
    {
      printf("\nb = %d is the smallest.", b);
    }
    else
    {
      printf("\nc = %d is the smallest.", c);
    }
  }
  return 0;  
}