fbpixel
Etiquetas:,
0
(0)

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

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?