Étiquettes : ,
0
(0)

L’instruction switch..case est un structure conditionnelle qui exécute différents bloc d’instruction en fonction de la valeur d’une variable. Cette instruction est équivalente à des instructions if imbriquées.

Syntaxe de l’instruction switch

L’instruction switch prend généralement, en entrée, une variable sous forme d’entier( integer ou int) et exécute différent bloc d’instructions selon sa valeur. Les blocs d’instructions sont placés sous des instructions case. A chaque exécution, l’instruction va comparer la valeur de val avec les valeurs val1, val2, etc. et exécuter les blocs de code correspondants.

  switch (val) {
    case val1:
      // instructions si val=val1
      break;
    case val2:
      // instructions si val=val2
      break;
    default:
      // instructions par défaut
      break;
  }

Dans l’exemple suivant, on définit une variable val qu’on incrémente à chaque boucle. L’instruction switch exécute le code correspondant à la valeur de val. Vous remarquerez que lorsque la valeur de val n’est pas définie dans un case, le code sous l’instruction default est exécutée.

int val=0;

void setup() {
  Serial.begin(9600);  
}

void loop() {
  switch (val) {
    case 0:
      Serial.println("ZERO");
      break;
    case 1:
       Serial.println("ONE");
      break;
    case 2:
       Serial.println("TWO");
      break;
    case 3:
       Serial.println("THREE");
      break;
    default:
      Serial.println("UNDEFINED");
      break;
  }
  val++;
  if(val>5) val=0;
  delay(500);
}

Constructions annexes

Utilisation d’une variable de type char

La variable à tester est généralement un entier mais elle peut aussi être une variable de type char. A ne pas confondre avec une chaine de caractères (un tableau de char ou un String).

char val='a';

void setup() {
  Serial.begin(9600);  
}

void loop() {
  switch (val) {
    case 'a':
      Serial.println("A");
      val='b';
      break;
    case 'b':
       Serial.println("B");
       val='d';
      break;
    case 'c':
       Serial.println("C");
       val='a';
      break;
    case 'd':
       Serial.println("D");
       val='c';
      break;
    default:
      Serial.println("UNDEFINED");
      break;
  }
  delay(500);
}

Rassemblement de plusieurs cases pour un bloc d’instruction

En enlevant l’instruction break, il est possible d’exécuter un même bloc d’instruction dans différents cas. Cela permet de ne pas réécrire le bloc d’instruction lorsque la fonction est la même dans différents cas.

char val=0;

void setup() {
  Serial.begin(9600);  
}

void loop() {
  switch (val) {
    case 1:
    case 3:
    case 5:
    case 7:
    case 9:
      Serial.println("IMPAIR");
      break;
    case 2:
    case 4:
    case 6:
    case 8:
      Serial.println("PAIR");
      break;
    default:
      Serial.println("> 10");
      break;
  }
  val++;
  if(val>10) val=0;
  delay(500);
}

Ce qu’il faut retenir

  • l’instruction switch prend en entrée une variable int ou char placée entre parenthèses
  • le bloc d’instruction switch se trouve entre accolades {}
  • l’instruction case prend en entrée un int ou un char suivie de « : »
  • Il faut rajouter l’instruction break après le bloc d’instruction case pour ne pas exécuter les suivants
  • Il est possible de rassembler plusieurs cases pour un même bloc d’instruction
  • Il est possible d’oublier le bloc d’instruction default.

Bonus

L’instruction switch case est souvent utilisée en combinaison de numérateurs enum qui est un type de structure contenant des entiers constants. Le type enum est une méthode d’initialisation pratique permettant de définir une multitude d’entier d’affiler.

enum alphabet{
  ALPHA,
  BETA,
  GAMMA,
  UNKNOWN
};

Dans cet exemple, les variables ALPHA, BETA, GAMMA, UNKNOWN prendront respectivement les valeurs 0,1,2 et 3. Toute variable ajoutée à la suite de cette liste prendra une valeur égale à la valeur précédente incrémentée de 1. Par ailleurs, il est possible, à tout moment, de définir explicitement la valeur de la variable et ainsi modifier le point de départ de l’énumération.

enum alphabet{
  ALPHA=0,
  BETA,
  GAMMA=9,
  UNKNOWN
};

Dans cet exemple, les valeurs définies sont:

  • ALPHA=0
  • BETA=1
  • GAMMA=9
  • UNKNOWN=10

Un numérateur peut être utilisée pour représenter une machine d’état qui est une méthode pratique lorsqu’on veut gérer un système complexe comme l’algorithme d’un robot.

enum States{
  INITIALIZED,
  WAITING,
  FAILED,
  VALID
};
int state=0;

void setup() {
  Serial.begin(9600);  
}

void loop() {
  switch (state) {
    case INITIALIZED:
      Serial.println("INITIALIZED");
      break;
    case WAITING:
       Serial.println("WAITING");
      break;
    case VALID:
       Serial.println("VALID");
      break;
    case FAILED:
       Serial.println("FAILED");
      break;
    default:
      Serial.println("DEFAULT");
      break;
  }
  state++;
  if(state>5) state=0;
  delay(500);
}

Sources

Retrouvez nos tutoriels et d’autres exemples dans notre générateur automatique de code
La Programmerie

How useful was this post?

Click on a star to rate it!

Average rating 0 / 5. Vote count: 0

No votes so far! Be the first to rate this post.

As you found this post useful...

Follow us on social media!

We are sorry that this post was not useful for you!

Let us improve this post!

Tell us how we can improve this post?