MCO018703 2018 2 AULA05: mudanças entre as edições

De MediaWiki do Campus São José
Ir para navegação Ir para pesquisar
Douglas (discussão | contribs)
Criou página com '=Objetivos= *O aluno será capaz de implementar estruturas de repetição em linguagem C. *Implementar ''loops'' infinitos. *Uso do break associado ao comando ''for''. =Estrutu...'
 
 
(30 revisões intermediárias por 2 usuários não estão sendo mostradas)
Linha 1: Linha 1:
=Objetivos=
=Objetivo=


*O aluno será capaz de implementar estruturas de repetição em linguagem C.
*Aprender sobre o comando de repetição ''while'' controlado por condição;
*Implementar ''loops'' infinitos.
*Saber usar o comando ''while'' e ''do while''.
*Uso do break associado ao comando ''for''.


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


Existem 4 estruturas/comandos que permitem implementar ''loops'' ou repetições de blocos de código:
==while( )==
*''while()''
*''do while()''
*''for()''
*''goto label''


<blockquote style="background: #FFEEFF; border: 1px solid red; margin-left: 0px; margin-right: 0px; padding: 1em;">
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:
Nota 1: Observe que repetir o código significa voltar a executá-lo, normalmente sobre o controle de uma expressão lógica.
</blockquote>
 
 
 
==Comando ''for()'' ==
 
O comando ''for()'' permite uma forma mais elaborada de ''loop'', com controle no início do bloco de repetição.
 
;Sua forma geral é
 
for(inicialização;condição;incremento) declaração;
 
;ou
 
for(inicialização;condição;incremento){
  declaração1;
  declaração2;
}
 
 
 
[[arquivo:ComandoFor.gif|thumb|right| Estrutura de Repetição]]


<syntaxhighlight lang=c>
<syntaxhighlight lang=c>
#include <stdio.h>
while (expressão) {
 
  bloco de instruções;    
main()
{
  int i;
 
  for (i=0;i<10;i=i+1)
      printf("i =%d\n",i);
}
}
</syntaxhighlight>
</syntaxhighlight>


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'''.


{| border="1" cellpadding="5" cellspacing="0"
[[imagem:Fig039_MCO018703.jpg|600px|center]]
! style="color:white;background: #1E90FF;" | Fluxograma
<center>
! style="color:white;background: #1E90FF;" | C
Figura 1 - Controle de Fluxo com os comandos '''while''' e '''do while'''.
! style="color:white;background: #1E90FF;" | Comentário
</center>
|-
| |[[imagem:FluxogramaComandoFor-Eraldo.jpg|300px]]
||<syntaxhighlight lang=c>
for(i=0; i<10; i++) {
  printf("Laço de número %d\n", i);
  if (i==5)
      printf("Este é o laço 5\n");
}
</syntaxhighlight>|| Observe que a expressão ''i=0'' é executada SEMPRE e uma única VEZ, <br>no início do comando.
A expressão ''i<10'' é o controle do ''loop''. Se FALSA o ''loop'' é encerrado. <br>Ela é executada após a expressão
de inicialização e, na sequência,  <br>no início de cada ''loop''. <br>A expressão i++ é executada no final de cada ''loop''.
|}
 
==Aninhamento de loops==
 
<syntaxhighlight lang=c>
#include <stdio.h>
main()
{
  int i,j;
  for (i=0;i<3;i++) {
    for (j=0;j<4;j++) {
        printf("valor de j = %d\n", j);
    }
    printf("valor de i = %d\n", i);
  }
}
</syntaxhighlight>
 
=Loop Infinito=


É possível implementar loops infinitos com qualquer uma das instruções acima.
===Exemplo===


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


<syntaxhighlight lang=c>
<syntaxhighlight lang=c>
main()
int contador;
void setup( )  
{
{
   for(;;) {
   Serial.begin(9600); // inicializa a porta serial
        /* Este bloco se executará infinitamente */
  }
}
}
</syntaxhighlight>
void loop( )  
 
;Exemplo
 
Usando o comando '''for''' aninhado, construa um programa que implemente a figura abaixo. <br>
 
:x
:xx
:xxx
:xxxx
:xxxxx
:xxxxxx
:xxxxxxx
:xxxxxxxx
:xxxxxxxxx
:xxxxxxxxxx
:xxxxxxxxxxx
:xxxxxxxxxxxx
:xxxxxxxxxxxxx
 
 
<syntaxhighlight lang=c>
#include <stdio.h>
main()
{
{
   int i,j;
   contador=0;
   printf("\n"); /* deixa uma linha em branco */
   while (contador<5) { 
 
    Serial.print("valor do contador: "); // imprime o texto entre ""
  for (i=0;i<13;i++) {
    Serial.println(contador); // imprime o valor do contador
        for (j=0;j<=i;j++) {
    contador=contador+1;
          printf("*");
    delay(500);
        }
  printf("\n"); /* deixa uma linha em branco */
   }
   }
}
}
</syntaxhighlight>
</syntaxhighlight>


==do...while==


==Uso de ''BREAK'' para sair de ''loops''==
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:
 
Em exercícios anteriores, a finalização de um ''loop'' normalmente se dá pela expressão de controle de ''loop'' associado a instrução usada.<br>
É possível sair de um ''loop'' na "força bruta" usando a instrução ''break'':


<syntaxhighlight lang=c>
<syntaxhighlight lang=c>
#include <stdio.h>
do {
main()
  bloco de instruções;                              
{
  int i,j;
 
  for (i=0;i<10;i++) {
    if (i==5)
      break;
  }
  printf("valor de i=%d\n", i);
}
}
 
while (expressão);
</syntaxhighlight>
</syntaxhighlight>


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


Note que o ''break'' sempre sai do ''loop'' mais próximo a ele. Muitas vezes rodamos um looping, através de um laço (como FOR ou WHILE), para encontrar alguma informação. O break serve para terminar o laço a qualquer momento sem esperar que o ''loop'' termine.


===Exemplo===


<syntaxhighlight lang=c>
Nesta variação do comando '''do while''' permite a repetição de uma ou mais instruções, com controle do loop no final.
#include <stdio.h>
Isto permite que o bloco seja executado pelo menos uma vez.  
main()
{
  int i,j;


  for (i=0;i<3;i++) {
    for (j=0;j<4;j++) {
        if (j==1) {
            break;
        }
        printf("valor de j = %d\n", j);
    }
    if (i==2)
        break;
    printf("valor de i = %d\n", i);
  }
}
</syntaxhighlight>
;Desafio 1
Encontre o primeiro número, entre 1 e 1 milhão que é divisível por 11, 13 e 17. Isso significa dizer que temos que encontrar o menor número que, dividido por 11, 13 e 17, dê resto da divisão nulo (igual a zero).
{{collapse top|Solução}}
<syntaxhighlight lang=c>
<syntaxhighlight lang=c>
#include <stdio.h>
int contador;
 
void setup( )  
int main()
{
{
    int count,
  Serial.begin(9600); // inicializa a porta serial
        numero=0;
 
    for(count=1 ; count<=1000000 ; count++)
    {
        if(numero == 0)
            if((count%11==0) && (count%13==0) && (count%17==0))
            {
                numero=count;
                break;
            }
        }
        printf("O numero e: %d\n", numero);
}
}
</syntaxhighlight>
void loop( )  
{{collapse bottom}}
 
==Uso do ''CONTINUE'' para prosseguir no início do ''loop''==
 
<syntaxhighlight lang=c>
#include <stdio.h>
main()
{
{
   int i,j;
   contador=0;
 
  do {
  for (i=0;i<3;i++) {
     Serial.print("valor do contador: "); // imprime o texto entre ""
    if (i==1) {  
     Serial.println(contador); // imprime o valor do contador
        continue;
    contador=contador+1;
    }
    delay(500);  
     printf("valor de j = %d\n", j);
   } while (contador<5);
     for (j=0;j<4;j++) {
        if (j==1) {
            continue;
        }
        printf("valor de j = %d\n", j);
    }
   }
 
}
}
</syntaxhighlight>
</syntaxhighlight>


==for==


O comando CONTINUE, quando inserido dentro de algum laço, faz com que a iteração atual seja cancelada, e o laço prossegue na próxima iteração. Ou seja, o BREAK faz todo o laço parar enquanto o CONTINUE, faz somente com que a iteração pule pra próxima.
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:
 
;Desafio 2
 
Faça um programa em C que some todos os números, de 1 até 100, exceto os múltiplos de 3. Faça o laço for percorrer de 1 até 100 e teste se cada número deixa resto 0 quando dividido por 3. Caso deixe, é porque é múltiplo de 3 e não devemos somar. Para que isso ocorra, simplesmente pulamos essa iteração. Porém, se não for múltiplo de 3, é porque a iteração não foi pulada, ela continua, e vamos somar esse número na soma total.
 


{{collapse top|Solução}}
<syntaxhighlight lang=c>
<syntaxhighlight lang=c>
#include <stdio.h>
for (variável;expressão;incremento) {
 
  bloco de instruções;  
int main()
{
        int count,
            soma;
 
        for(count=1, soma=0 ; count<=100 ; count++)
        {
            if( count%3 ==0)
                continue;
 
            soma = soma + count;
        }
 
 
        printf("Soma %d", soma);
 
}
}
</syntaxhighlight>
</syntaxhighlight>
{{collapse bottom}}


<!--
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.


<syntaxhighlight lang=c>
[[imagem:Fig040_MCO018703.jpg|300px|center]]
#include <stdio.h>
<center>
Figura 2 - Controle de Fluxo com o comando '''for'''.
</center>


void imp_linha_cheia(int margem, int num_caracteres, char car1)
===Exemplo 1===
{
  int i;


  for(i=0;i<margem;i++)
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.
printf(" ");
  for(i=0;i<num_caracteres;i++)
printf("%c", car1);
  printf("\n"); 
}


void imp_linha_vazada(int margem, int num_vazados, char car1)
<syntaxhighlight lang=c>
void setup( )  
{
{
  int i;
  Serial.begin(9600); // inicializa a porta serial
 
  for(i=0;i<margem;i++)
printf(" ");
  printf("%c", car1);
  for(i=0;i<num_vazados;i++)
printf(" ");
  printf("%c\n", car1);  
}
}
 
void loop( )  
void plot_ret(int margem, int num_vazados, int num_linhas_vazado, char car1)
{
{
  int i;
  for (int i=0; i < 10; i++)
 
     Serial.println(i); // imprime o valor de i
  imp_linha_cheia(margem, num_vazados+2, car1);
    delay(1000);  
  for(i=0;i<num_linhas_vazado;i++)
  }
     imp_linha_vazada(margem, num_vazados, car1);
  imp_linha_cheia(margem, num_vazados+2, car1);
}
}
</syntaxhighlight>
</syntaxhighlight>


===Exemplo 2===


{{collapse bottom}}
No código abaixo vemos um exemplo de dois loops aninhados. Enquanto '''i''' conta as linhas '''j''' conta as colunas.
 
 
 
{{collapse top|AULA 6 DIA 28/02/2014}}
 
Exercícios
 
1.Usando o comando for aninhado, construa um programa que implemente a figura abaixo. A margem esquerda (margem de espaços), o caracter do desenho, o número de linhas vazadas e o tamanho horizontal da figura deve ser lido pelo teclado.
  aaaaaaaaaa
  a        a
  aaaaaaaaaa


<syntaxhighlight lang=c>
<syntaxhighlight lang=c>
#include <stdio.h>
int i,j; // i e j são variáveis inteiras


main()
void setup( )  
{
{
  int i, j,num_linhas, num_colunas, margem;
  Serial.begin(9600); // inicializa a porta serial
 
 
  printf("Entre com linhas\n");
  scanf ("%d",&num_linhas);
 
  printf("Entre com colunas\n");
  scanf ("%d",&num_colunas);
 
  printf("Entre com margem\n");
  scanf ("%d",&margem);
 
 
  /* subproblema 1 */
 
  for (i=0;i<margem;i=i+1)
        printf(" ");
  for (i=0;i<num_colunas;i=i+1)
printf("A");
  printf("\n");
 
  /*subproblema 3 */
  for(j=0;j<num_linhas-2;j++) {
 
        /*subproblema 2 */
 
  for (i=0;i<margem;i=i+1)
printf(" ");
 
  printf("A");
 
  for(i=0;i<num_colunas-2;i=i+1)
printf(" ");
 
  printf("A");
        printf("\n");
  }
 
  /* subproblema 1 */
 
  for (i=0;i<margem;i=i+1)
        printf(" ");
  for (i=0;i<num_colunas;i=i+1)
printf("A");
  printf("\n");
 
}
}
</syntaxhighlight>
void loop( )  
 
2.Construa um programa para desenhar a seguinte figura de forma parametrizável:
 
  AAAAAAAAAAAAAAAA
  AAAAAAAAAAAAAA
  AAAAAAAAAAAA
  AAAAAAAAAA
  AAAAAAAA
  AAAAAA
  AAAA
  AA
  BB
  BBBBB
  BBBBBBBB
  BBBBBBBBBBB
  BBBBBBBBBBBBBB
  BBBBBBBBBBBBBBBBB
  BBBBBBBBBBBBBBBBBBBB
  BBBBBBBBBBBBBBBBBBBBBBB
 
3.#Estude o programa ([http://stackoverflow.com/questions/5743678/how-to-generate-random-number-between-0-and-10-in-c referência]) abaixo:
<syntaxhighlight lang=c>
/* rand example: guess the number */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
int main ()
{
{
      int iSecret, iGuess;
  for (i=0;i<13;i++) {
 
         for (j=0;j<=i;j++) {
      /* initialize random seed: */
           Serial.print('*'); // imprime um asterisco
         srand ( time(NULL) );
           delay(100);  
 
        }
      /* generate secret number: */
        Serial.println(); // pula uma linha
      iSecret = rand() % 10 + 1;
        delay(50);
 
  }
      do {
           printf ("Guess the number (1 to 10): ");
           scanf ("%d",&iGuess);
          if (iSecret<iGuess)
              printf ("The secret number is lower\n");
          else {
              if (iSecret>iGuess)
                printf ("The secret number is higher\n");
          }
      } while (iSecret!=iGuess);
 
      printf ("Congratulations!\n");
      return 0;
}
}
</syntaxhighlight> Estude também o significado das instruções:
</syntaxhighlight>
  srand ( time(NULL) );
  iSecret = rand() % 10 + 1;
 
4.Sobre o exercício 3, implemente uma versão usando o comando while().
 
5.Elabore um programa que lê um número inteiro e imprime todos os números pares entre 1 e este número.
 
 
-->


=Referências=


[1] http://linguagemc.com.br/comando-do-while/


-----
-----

Edição atual tal como às 15h31min de 28 de agosto de 2018

1 Objetivo

  • Aprender sobre o comando de repetição while controlado por condição;
  • Saber usar o comando while e do while.

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

2.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.

2.1.1 Exemplo

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

2.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.


2.2.1 Exemplo

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

2.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.

2.3.1 Exemplo 1

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

2.3.2 Exemplo 2

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

3 Referências

[1] http://linguagemc.com.br/comando-do-while/