MCO018703 2024 2 AULA06

1 Estruturas de Decisão e Repetição

OBJETIVOS

O aluno será capaz de:

• Conhecer os operadores relacionais e lógicos;
• Identificar as funções para controle de fluxo;
• Saber utilizar os comandos de decisão; e
• Saber utilizar os comandos de repetição.

METODOLOGIA

A aula será expositiva e dialogada, utilizando apresentação de texto base na Internet, onde serão mostrados exemplos executados programas para programação de microcontroladores. Na prática faremos testes de comunicação serial com o Arduino através da porta USB.

INTRODUÇÃO

Em linguagem de programação, uma estrutura de decisão permite decidir por executar ou não certo conjunto de comandos, de acordo com uma determinada condição. Em linguagem C do Arduino existem duas formas de representar um processo de decisão, usando a estrutura if-else ou a estrutura switch-case. Já uma estrutura de repetição é comum aparecer nos casos em que um comando ou um determinado conjunto de comandos devem ser repetidos uma certa quantidade de vezes ou repetidos de acordo com alguma condição. Portanto, é necessário algum mecanismo para se representar a repetição de comandos em um algoritmo. Na linguagem C existem três estruturas de repetição: while, do while e for. Como estas estruturas podem ser controlador por uma condição, vamos dar uma passada nos operadores relacionais e lógicos utilizadas nesses comandos.

1.1 Operadores Relacionais e Lógicos

Os operadores relacionais são expressões que resultam em valores: TRUE (verdadeiro ou '1' lógico) ou FALSE (falso ou '0' lógico). A expressão deve sempre ser lida da esquerda para a direita.

EXEMPLO 1

Sendo as variáveis A e B inteiras, veja a expressão: (A >= B) → "O valor de A é maior ou igual a B", se for maior, e, também, ser for igual, o resultado será verdadeiro (TRUE). Ser for menor, ou seja, a variável B é maior, o resultado será falso (FALSE). Veja a tabela e os exemplos abaixo:

Operador	Significado	Exemplo
>	maior que	A > B
>=	maior ou igual que	A >= -1
<	menor que	B < 2
<=	menor ou igual que	A <= B
==	igual a	B == 0
!=	diferente de	B != A

Já os operadores lógicos envolvem expressões cujo o resultado também é uma expressão lógica TRUE ou FALSE (verdadeiro ou falso). Funcionam de maneira semelhante as portas lógicas digitais: AND (E), OR (OU) e NOT (NÃO/INVERSORA).

EXEMPLO 2

Sendo as variáveis A, B e C inteiras, veja a expressão: (A > B) && (A < C) → "O valor de A é maior que o valor de B 'E' e o valor de A é menor que o valor de C" , se ambos os resultados forem verdadeiros (TRUE) o resultado da expressão será verdadeiro (TRUE). Se pelo menos uma das comparações for falsa (FALSE), o resultado será falso (FALSE). Veja a tabela e os exemplos abaixo:

Operador	Significado	Exemplo
&&	AND (E)	(A<B) && (B!=0)
||	OR (OU)	(B>1)||(A==0)
!	NOT (NÃO)	!(A<=B)

* Atenção para o uso dos parênteses.

EXERCÍCIO

(FALSE && FALSE) → FALSE
(FALSE && TRUE)  → FALSE
(TRUE && FALSE)  → FALSE
(TRUE && TRUE)   → TRUE
(FALSE || FALSE) → FALSE
(FALSE || TRUE)  → TRUE
(TRUE || FALSE)  → TRUE
(TRUE || TRUE)   → TRUE
!(FALSE)         → TRUE
!(TRUE)          → FALSE
!(TRUE && FALSE) → TRUE

Ver Operadores Relacionais e Lógicos

1.2 Funções para Controle de Fluxo - Decisão

1.2.1 if( )

É um controle de fluxo usado para selecionar uma ou mais instruções baseado no resultado de um teste de comparação. Todas as instruções entre as chaves { } são executadas somente se o resultado desse teste for verdadeiro; se não, essas instruções não são executadas. Verdadeiro é qualquer resultado, mesmo negativo, diferente de zero. Falso é um resultado zero. A Figura 1 mostra o controle de fluxo utilizando os comandos if e if...else.

if (expressão){
   bloco de instruções; // se "expressão" for verdadeira, "bloco de instruções" é executado
}

Figura 3 - Controle de Fluxo com os comandos if e if...else.

1.2.2 if( )...else

Ao se acrescentar mais um bloco de instruções no loop do comando if pode-se criar o comando if...else (Figura 1), para fazer um novo teste quando o resultado da expressão for falsa.

if (expressão) {
   bloco de instruções1; // se "expressão" for verdadeira, "bloco de instruções1" é executado
}
else {
   bloco de instruções2; // se "expressão" for falsa, "bloco de instruções2" é executado 
}

1.2.3 if( )...else if( )

E de novo ao se acrescentar agora o comando if...else no loop do comando if pode-se criar mais um outro comando, o if...else if. No exemplo abaixo se "expressão1" for verdadeira o "bloco de instruções1" é executado; se "expressão1" for falsa mas "expressão2" for verdadeira "bloco de instruções2" é executado; e se "expressão1" e "expressão2" forem falsas o "bloco de instruções3" é executado. A Figura 2 mostra os comandos if( )...else if( ) e switch...case.

Figura 4 - Controle de Fluxo usando os comandos if( )...else if( ) e switch...case.

if (expressão1) {
   bloco de comandos1; 
}
else if (expressão2) {
   bloco de instruções2; 
}
else {
   bloco de comandos3; 
}

1.2.4 switch...case

É possível ir inserindo comandos if...else na posição do segundo bloco de instruções de outro comando if...else e assim criar uma cadeia de comandos para testar dezenas de expressões até encontrar uma que retorne um resultado verdadeiro e executar um dos blocos de instruções; mas existe um comando próprio que simplifica bastante essa seleção, é o comando switch...case (Figura 2). Esse comando permite comparar uma mesma variável inteira, ou uma expressão que retorne um inteiro, com vários valores possíveis.

switch..,case

switch (expressão) {
  case 1:  bloco de instruções1; 
           break;
  case 2:  bloco de instruções2; 
           break;
  case 3:  bloco de instruções3; 
           break;
  default: bloco de instruções4; 
}

1.3 Funções para Controle de Fluxo - Repetição

1.3.1 while( )

Uma das operações mais frequentes que os programas executam é repetir um grupo de instruções até que uma condição inicialmente verdadeira se torne falsa. É para isso que serve o comando while. A sua sintaxe é a seguinte:

while (expressão) {
   bloco de instruções;     
}

O bloco de instruções será executado enquanto o parâmetro expressão for verdadeiro. A Figura 1 mostra o comando while e do while.

Figura 1 - Controle de Fluxo com os comandos while e do while.

EXEMPLO 1

O exemplo abaixo mostra como o comando while permite implementar loops com controle no início.

int contador;
void setup( ) 
{
   Serial.begin(9600); // inicializa a porta serial 
}
void loop( ) 
{
  contador=0;
  while (contador<5) {  
     Serial.print("valor do contador: "); // imprime o texto entre ""
     Serial.println(contador); // imprime o valor do contador
     contador=contador+1;
     delay(500);
  }
}

1.3.2 do...while

Para que o bloco de instruções seja executado ao menos uma vez, ele é deslocado para a entrada da caixa de decisões, antes do teste de validade:

do {
   bloco de instruções;                                
}
while (expressão);

Aqui o "bloco de instruções" será executado primeiro e só então o parâmetro "expressão" é avaliado. Veja na Figura 1.

EXEMPLO 2

Nesta variação do comando do while permite a repetição de uma ou mais instruções, com controle do loop no final. Isto permite que o bloco seja executado pelo menos uma vez.

int contador;
void setup( ) 
{
   Serial.begin(9600); // inicializa a porta serial 
}
void loop( ) 
{
  contador=0;
  do {  
     Serial.print("valor do contador: "); // imprime o texto entre ""
     Serial.println(contador); // imprime o valor do contador
     contador=contador+1;
     delay(500); 
  } while (contador<5);
}

1.3.3 for

Inserindo-se no loop do comando while um contador que registre cada execução do bloco de instruções cria-se o comando for. Esse contador deve ter uma variável de controle que deve ser previamente inicializada com um tipo e um valor. A sua sintaxe é a seguinte:

for (variável;expressão;incremento) {
   bloco de instruções; 
}

A variável é inicializada normalmente com 0 ou 1; o parâmetro expressão deve conter o valor máximo (ou mínimo) que o contador deve alcançar; e incremento é o valor que será incrementado (ou decrementado) da variável cada vez que o bloco de instruções é executado. Observe que cada parâmetro entre parênteses é separado por ponto e vírgula.

Figura 2 - Controle de Fluxo com o comando for.

EXEMPLO 3

No código abaixo a variável de controle i do contador criada e inicializada com 0; o contador é testado e se o valor nele acumulado for menor que 10 seu valor é enviado para o Terminal, e depois de 1 segundo, o contador é incrementado e seu novo valor é testado novamente.

void setup( ) 
{
   Serial.begin(9600); // inicializa a porta serial 
}
void loop( ) 
{
   for (int i=0; i < 10; i++) {   
     Serial.println(i); // imprime o valor de i 
     delay(1000);    
   }
}

EXEMPLO 4

No código abaixo vemos um exemplo de dois loops aninhados. Enquanto i conta as linhas j conta as colunas.

int i,j; // i e j são variáveis inteiras

void setup( ) 
{
   Serial.begin(9600); // inicializa a porta serial 
}
void loop( ) 
{
  for (i=0;i<13;i++) {
        for (j=0;j<=i;j++) {
          Serial.print('*'); // imprime um asterisco 
          delay(100);    
        }
        Serial.println(); // pula uma linha
        delay(50);
   }
}

2 Responda

1. Para que serve os operadores relacionais e lǵicos?
2. Qual a diferença entre operador relacional e operador lógico?
3. Quais os resultado esperados de uma comparação lógica?
4. Quais os controles de fluxo que você viu nessa aula?
5. Dê um exemplo de uso do comando if...else'.
6. Dê um exemplo de estrutura de repetição.

3 Referências

[1] https://ruandg.github.io/decisaorepeticao.html

---