Uma rápida olhada na instrução switch em C

A instrução switch..case é uma estrutura condicional que executa diferentes blocos de instruções dependendo do valor de uma variável. Ela equivale a instruções if aninhadas.

Sintaxe da instrução switch

A instrução switch toma geralmente como entrada uma variável sob a forma de inteiro (integer ou int) e executa diferentes blocos de instruções dependendo do seu valor. Os blocos de instruções são colocados sob instruções case. A cada execução, a instrução switch compara o valor de val com os valores de val1, val2, etc. e executa os blocos de código correspondentes.

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

No exemplo a seguir, definimos uma variável val que se incrementa a cada loop. A instrução switch executa o código correspondente ao valor de val. Podemos observar que, quando o valor de val não é definido num case, o código sob a instrução defaut é executado.

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);
}

Construções anexas

Uso de uma variável de tipo char

A variável a testar é normalmente um inteiro, mas também pode ser uma variável do tipo char. A não se confundir com uma cadeia de caracteres (uma matriz de caracteres ou um 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);
}

Reunião de vários cases para um bloco de instruções

Ao remover a instrução break, é possível executar o mesmo bloco de instruções para cases diferentes. Com isso, torna-se desnecessário reescrever o bloco quando a função é a mesma para diferentes cases.

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);
}

Para lembrar

• A instrução switch toma como entrada uma variável int ou char colocada entre parênteses.
• O bloco de instruções switch é escrito entre chaves {}.
• A instrução case toma como entrada um int ou um char seguido de “:”.
• Acrescentamos a instrução break após o bloco de instruções case para evitar a execução dos blocos seguintes.
• É possível reunir vários cases para o mesmo bloco de instruções.
• É possível dispensar o bloco de instruções defaut.

Bônus

A declaração switch case é frequentemente utilizada em combinação com numeradores enum, que são um tipo de estrutura contendo inteiros constantes. O emprego do tipo enum é um método de inicialização conveniente para definir uma multiplicidade de inteiros em sequência.

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

Neste exemplo, as variáveis ALPHA, BETA, GAMMA, UNKNOWN assumirão os valores 0, 1, 2 e 3 respectivamente. Qualquer variável acrescentada após essa lista terá um valor igual ao valor anterior acrescido de 1. Também é possível, a qualquer momento, definir explicitamente o valor da variável e assim modificar o ponto de partida da enumeração.

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

Neste exemplo, os valores definidos são:

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

Um numerador pode ser usado para representar uma máquina de estado. Este é um método prático para gerenciar um sistema complexo, como o algoritmo de um robô.

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);
}

Fontes

• C Language norm ISO
• Referência Arduino Switch
• Referência Arduino enum
• Programar com o Arduino