Les instructions switch en C++

  2. HowTo
  3. C++ Howtos
  4. Les instructions switch en C++
Suraj P 12 octobre 2023
C++ C++ Statement
  1. l’instruction switch-case en C++
  2. Règles et propriétés dans l’utilisation de la casse en C++
  3. Différence entre les instructions switch et les instructions if-else en C++
Les instructions switch en C++

Dans cet article, nous allons découvrir les instructions switch en C++ et leurs propriétés particulières.

l’instruction switch-case en C++

Le switch-case évalue l’expression, en fonction de sa valeur, et est testé par rapport à une liste de valeurs constantes présentes dans les déclarations case pour effectuer différentes actions en fonction de différents cases.

Comme if-else, les instructions switch sont des instructions de contrôle de flux car elles peuvent modifier le flux général d’un programme car elles permettent à une expression ou à une variable de contrôler le flux via un branchement multidirectionnel.

Syntaxe:

switch(variable / expression)
{
case constant-expression 1:
  statements;

case constant-expression 2:
  statements;
}

Exemple de code :

#include <iostream>
using namespace std;

int main() {
  int day = 3;
  switch (day) {
    case 1:
      cout << "Monday\n";

    case 2:
      cout << "Tuesday\n";

    case 3:
      cout << "Wednesday\n";

    case 4:
      cout << "Thursday\n";

    case 5:
      cout << "Friday\n";

    case 6:
      cout << "Saturday\n";

    case 7:
      cout << "Sunday\n";
  }
}

Production:

Wednesday
Thursday
Friday
Saturday
Sunday

La valeur de la variable day = 3 est évaluée et mise en correspondance avec l’instruction de cas respective qui est case 3, et l’instruction qu’elle contient qui est "Wednesday" est imprimée, mais nous obtenons toujours les chaînes restantes car une fois le le contrôle passe au case 3, tout à partir de là jusqu’à la fin du bloc de commutation, toutes les instructions sont imprimées/évaluées.

C’est pourquoi les déclarations des case 4,5,6,7 sont imprimées.

Pour éviter cela, nous devons modifier notre structure switch-case.

Syntaxe - switch-case modifié :

switch(variable / expression)
{
case constant-expression 1:
  statements;
  break; (optional)

case constant-expression 2:
  statements;
  break; (optional)

default:  //default statment optional
  statements;
  break;
}

Le mot-clé break est utilisé pour arrêter l’exécution du bloc switch et en sortir. Une fois que la condition/le cas est satisfait, nous évaluons les instructions, brisons le flux et sortons du bloc de commutation.

Le mot-clé default spécifie les instructions exécutées lorsqu’aucune casse ne correspond.

Exemple de code :

#include <iostream>
using namespace std;

int main() {
  int day = 3;
  switch (day) {
    case 1:
      cout << "Monday\n";
      break;
    case 2:
      cout << "Tuesday\n";
      break;

    case 3:
      cout << "Wednesday\n";
      break;
    case 4:
      cout << "Thursday\n";
      break;

    case 5:
      cout << "Friday\n";
      break;

    case 6:
      cout << "Saturday\n";
      break;

    case 7:
      cout << "Sunday\n";
      break;

    default:
      cout << "Wrong option entereted\n";
      break;
  }
}

Production:

Wednesday

Dans cet exemple suivant, nous pouvons également basculer avec char. Nous allons voir un exemple de code qui vérifie si un caractère est une voyelle ou une consonne.

Exemple de code :

#include <iostream>
using namespace std;

int main() {
  char x = 'u';

  switch (x) {
    case 'a':
      cout << "Vowel";
      break;
    case 'e':
      cout << "Vowel";
      break;
    case 'i':
      cout << "Vowel";
      break;
    case 'o':
      cout << "Vowel";
      break;
    case 'u':
      cout << "Vowel";
      break;

    default:
      cout << "Consonant";
      break;
  }
}

Production:

Vowel

Règles et propriétés dans l’utilisation de la casse en C++

  1. L’expression utilisée à l’intérieur de l’instruction switch doit être une valeur constante. Sinon, il sera considéré comme invalide.

Ici, nous pouvons voir que des expressions constantes et variables, à condition qu’elles soient affectées de valeurs fixes, peuvent être utilisées.

```c++
switch (1 + 2 + 3 * 4 + 5)
  switch (a + b + c * d)
```

  1. default et break sont optionnels. Même si le switch-case ne les a pas, il fonctionnera sans problème.

  2. L’imbrication des instructions switch est valide signifie que nous pouvons basculer des instructions à l’intérieur d’une autre. Bien que ce ne soit pas une bonne pratique de programmation, nous pouvons toujours les utiliser.

    #include <iostream>
using namespace std;

int main() {
  int ID = 1234;
  int password = 000;

  switch (ID) {
    case 1234:
      cout << "checking info......\n";

      switch (password) {
        case 000:
          cout << "Login successful\n";
          break;
        default:
          cout << "Password don't match please check it\n";
          break;
      }

      break;

    default:
      printf("incorrect ID");
      break;
  }
}

    Production:

    checking info......
Login successful

  3. L’expression utilisée à l’intérieur de l’instruction switch doit être un type intégral, ce qui signifie qu’elle doit être int, char ou enum. Sinon, nous obtenons une erreur de compilation.

    #include <iostream>
using namespace std;

int main() {
  float x = 12.34;

  switch (x) {
    case 1.1:
      cout << "Yes";
      break;
    case 12.34:
      cout << "NO";
      break;
  }
}

    Production:

    [Error] switch quantity not an integer

  4. Le bloc default peut être à l’intérieur du switch mais n’est exécuté que lorsqu’aucun cas ne correspond.

    #include <iostream>
using namespace std;

int main() {
  int x = 45;
  switch (x) {
    default:
      cout << "It's not 1 or 2";
      break;
    case 1:
      cout << "It's a 1";
      break;
    case 2:
      cout << "It's a 2";
      break;
  }
}

    Production:

    It's not 1 or 2

  5. Les déclarations écrites au-dessus du cas ne sont jamais exécutées. Une fois l’instruction switch évaluée, le contrôle passe soit à la casse correspondante, soit au bloc default, s’il est présent.

    #include <iostream>
using namespace std;

int main() {
  int x = 45;
  switch (x) {
    cout << "Tony is Iron Man\n";
    case 1:
      cout << "It's a 1";
      break;
    case 2:
      cout << "It's a 2";
      break;

    default:
      cout << "It's not 1 or 2";
      break;
  }
}

    Production:

    It's not 1 or 2

  6. Les étiquettes de cas en double ne sont pas autorisées. S’il est donné, nous aurons une erreur de compilation.

    #include <iostream>
using namespace std;

int main() {
  int x = 45;
  switch (x) {
    case 45:
      cout << "Iron Man";
      break;

    case 40 + 5:
      cout << "tony stark";
      break;

    default:
      cout << "It's not 1 or 2";
      break;
  }
}

    Production:

    [Error] duplicate case value

  7. Les étiquettes de cas doivent également être constantes. Sinon, nous obtenons une erreur de compilation.

    #include <iostream>
using namespace std;

int main() {
  int x = 2;
  int arr[] = {100, 200, 300};
  switch (x) {
    case arr[0]:
      cout << "Iron Man";
      break;

    case arr[1]:
      cout << "tony stark";
      break;

    case arr[2]:
      cout << "It's not 1 or 2";
      break;
  }
}

    Production:

    [Error] the value of 'arr' is not usable in a constant expression

  8. On peut regrouper tous les énoncés case réalisant la même tâche.

    #include <iostream>
using namespace std;

int main() {
  char x = 'A';

  switch (x) {
    case 'a':
    case 'e':
    case 'i':
    case 'o':
    case 'u':
    case 'A':
    case 'E':
    case 'I':
    case 'O':
    case 'U':
      cout << "Vowel";
      break;

    default:
      cout << "consonant";
  }
}

Différence entre les instructions switch et les instructions if-else en C++

Lorsque nous avons de nombreuses instructions if-else, le compilateur doit les vérifier toutes jusqu’à ce qu’il trouve une correspondance valide. Alors que les instructions switch-case sont utilisées si nous voulons qu’un certain bloc de code ne s’exécute que si une certaine condition est remplie.

L’exemple suivant vérifie si un caractère est un alphabet ou non.

Exemple de code :

char x = '+';

if (x == 'A')
....

    else if (x == 'B')...

    else if (x == 'C')...

    ....else cout
    << "Not an alphabet"

Puisque + n’est pas un alphabet, il faut beaucoup plus de temps pour atteindre le dernier car il faut d’abord examiner toutes les conditions précédentes. S’il est implémenté à l’aide de switch-case, il utilise une table de correspondance ou une liste de hachage lorsque le nombre de cas/conditions est très important.

Cela signifie que tous les éléments ont le même temps d’accès. Ainsi, lorsque nous avons de nombreux cas/conditions, le switch est préféré au if-else car il est plus rapide.

Auteur: Suraj P
Suraj P avatar Suraj P avatar

A technophile and a Big Data developer by passion. Loves developing advance C++ and Java applications in free time works as SME at Chegg where I help students with there doubts and assignments in the field of Computer Science.

LinkedIn GitHub

Article connexe - C++ Statement