Programar em C++/Estruturas de repetição

Origem: Wikilivros, livros abertos por um mundo aberto.
Saltar para a navegação Saltar para a pesquisa

Laços (loops em inglês), ou estruturas de repetição, são comandos existentes nas linguagens de programação destinados a executar uma ou mais instruções quantas vezes forem necessárias. Cada ciclo de um loop é chamado de iteração. Podemos ter também loops dentro de outro loop.

While[editar | editar código-fonte]

O while, "enquanto" em inglês, é um laço que ordena o computador a executar determinadas instruções enquanto uma condição for verdadeira. Isso faz com que um comando seja executado uma vez a cada verificação da condição. De modo geral o comando sempre deve ser elaborado de forma que se leve a condição de execução a ser falsa em algum momento, de forma a interromper o laço para que o resto do programa entre em execução.

Sintaxe[editar | editar código-fonte]

while (condição)
  comando;

Onde condição é a condição de execução do laço while.

O código abaixo mostra o uso do laço while para imprimir na tela do número 1 ao número 10. Perceba o uso de uma variável inteira intitulada contador. Esta variável é utilizada para armazenar um valor a ser impresso bem como participar da condição de execução do laço. Assim que a variável atingir o valor 11 o programa segue para o comando logo após o laço.

#include <iostream>

using namespace std;

int main()
{
  int contador;               // Declara a variável contador.
  contador=1;                 // contador recebe o valor 1.
  while (contador<=10)        // Enquanto contador for menor ou igual a 10.
  {
    cout << contador << endl; // Imprime contador.
    contador++;               // Incrementa contador em uma unidade.
  }
  return 0;
}

Do-While[editar | editar código-fonte]

O laço do-while é um while invertido, onde você coloca as instruções a serem repetidas antes da verificação da condição de execução. Isso significa que os comandos do laço serão executados ao menos uma vez.

Sintaxe[editar | editar código-fonte]

do {
  comando;
} while (condição);

Onde condição é a condição de execução do laço do-while. Os comandos pertencentes ao laço somente deixarão de se repetir quando a condição for falsa.

O algoritmo abaixo mostra como seria o algoritmo exemplo usado na seção do laço while convertido para o uso do laço do-while.

#include <iostream>

using namespace std;

int main()
{
  int contador;               // Declara a variável contador.
  contador=1;                 // contador recebe o valor 1.
  do {
    cout << contador << endl; // Imprime contador.
    contador++;               // Incrementa contador em uma unidade.
  } while (contador<=10);     // Enquanto contador for menor ou igual a 10.
  return 0;
}

For[editar | editar código-fonte]

Como o uso de uma variável como contador nos laços é algo frequente, foi criado um outro laço que traz em sua estrutura campos para abrigar os comandos de atribuição de valor inicial e incremento/decremento do contador. O nome deste laço é for, "para" em inglês.

Sintaxe[editar | editar código-fonte]

for ([inicialização]; [condição]; [incremento])
  comando;

Onde:

  • inicialização: campo destinado para qualquer comando que deve ser executado, uma única vez, logo no início do laço.
  • condição: campo destinado para a condição de parada. Esta condição é verificada logo no início do laço, imediatamente após a conclusão do parâmetro1 e a cada passo quando o <comando> é executado.
  • incremento: campo destinado para qualquer comando que deve ser executado todas as vezes em que o laço finalizar seu último comando, em todas as suas repetições.

O algoritmo abaixo mostra o uso do laço for manipulando a variável inteira contador de maneira a imprimir uma contagem de 1 até 10. Esse uso do laço for é o mais comum, pois possibilita uma repetição de comandos de número fixo, dez no algoritmo em questão.

#include <iostream>

using namespace std;

int main()
{
  int contador;                              // Declara a variável contador.
  for (contador=1; contador<=10; contador++) // Inicia o laço.
    cout << contador << endl;                // Imprime contador.
  return 0;
}

É importante deixar claro que nenhum dos três parâmetros utilizados no laço for é obrigatório. Caso não haja necessidade de utilizar um ou mais deles, basta deixar seu espaço em branco. Como exemplo temos o algoritmo a seguir, que demonstra um laço infinito usando for:

#include <iostream>

using namespace std;

int main()
{
  for (;;)
    cout << "Eu sou um laço infinito." << endl;
  return 0;
}

A ausência do 2º parâmetro significa loop infinito:

 for (int num =1; ; num++)
  {
     cout << num << " ";
  }

Isto vai colocar um valor a mais no num indefinidamente.

Ausência do 3º parâmetro:

 for (int num=1; num <= 10;    )
 {
     cout << num << " ";
     num++;
 }

Dicas[editar | editar código-fonte]

Bloco de Comandos[editar | editar código-fonte]

Em muitos casos, os laços devem repetir dois ou mais comandos. Para isso, necessitamos criar um bloco de comandos contendo todas as instruções a serem repetidas. A criação de um bloco de comandos é simples, basta colocar todos os comandos entre chaves { }. Os algoritmos de exemplo dos laços while e do-while fazem uso de um bloco de comandos.

Caso o laço não encontre a abertura de um bloco logo em seguida, ele assumirá que o comando imediatamente abaixo é o único que deve ser repetido.

Exemplo 1:

while (condição)
  comando1; // Este comando faz parte do laço.
comando2;   // Este comando não faz parte do laço.

Exemplo 2:

while (condição)
{
  comando1;  // Este comando faz parte do laço.
  comando2;  // Este comando faz parte do laço.
}

O Comando break[editar | editar código-fonte]

O que o break faz é quebrar a execução para fora do bloco de código onde ele está presente:

 #include <iostream>
 using namespace std;
 int main(void)
 {
   int num;
   char choice;
   bool quit = false;
   while (true)
   {
      cout << "Enter a positive number: ";
      cin >> num;
      if (num > 0)
      		break;
      else
      {
      cout << "Number must be positive; try again (Y/N): ";
      cin >> choice;
      if (choice != 'Y')
     	 {
      	quit = true;
      	break;
      	}
      }
   }
   if (quit == false)
      cout << "The number you entered is " << num << " ";
   else
      cout << "You did not enter a positive number";
   return 0;
 }

O break faz com que a execução do programa continue na primeira linha seguinte ao loop ou bloco

O Comando continue[editar | editar código-fonte]

Esta instrução é bem parecida com o break, mas algo diferente. Pois em vez de mandar a execução para fora do bloco manda-a para a avaliação do loop. Ou seja faz saltar uma determinada iteração do loop, enquanto o break faz acabar o loop

 #include <iostream>
 using namespace std;
 int main(void)
 {
   int num, counter = 0, total = 0;
   cout << "How many items do you want to buy: ";
   cin >> num;
   while (counter++ < num)
   {
      if (counter % 13 == 0)
         continue;
      total += 3;
   }
   cout << "Total for " << num << " items is $" << total;
   return 0;
 }

Neste exemplo quando o conter for múltiplo de 13, a instrução seguinte é saltada total+=3

Incrementar/decrementar[editar | editar código-fonte]

Aqui vamos voltar a um tópico anterior que foi abordado nos operadores Temos

  • a=a+1 é equivalente a ter a+=1 e ainda a ter a++

Mas isto tudo é só no caso do incremento ser 1.

Podemos ter ++a ou ainda a++. Eles são parecidos mas diferentes, é a questão do prefixo e pós-fixo. A diferença é que

  • O prefixo, faz o incremento ainda durante a instrução
  • O pós-fixo faz o incremento quando se passa para a instrução seguinte.
 #include <iostream>
 using namespace std;
 int main(void)
 {
   int num = 2;
   cout << num << ”\n;
   cout << ++num << ”\n;
   cout << num++ <<”\n;
   cout << num << ”\n;
   return 0;
 }

Portanto

  • int num = 5;
  • cout << (++num == 5);

Exercícios[editar | editar código-fonte]

Crie um programa que dê o fatorial de um número:

 #include <iostream>
 using namespace std;
 int main(void)
 {
   int num, counter, total = 1;
   cout << "Enter a number: ";
   cin >> num;
   cout << "The factorial of " << num << " is ";
   for (int counter = 1; counter <= num; counter++)
      total *= counter;
   cout << total;
   return 0;
 }

Crie um programa para o utilizador adivinhar um número de 0 a 3. Dê 3 hipóteses para adivinhar. No caso de acertar antes de chegar ao fim das 3 hipóteses termine.

 #include <iostream>
 using namespace std;
 int main(void)
 {
   int num, counter, secret = 3;
   cout << "Guess a number between 1 and 10\n";
   cout << "You have 3 tries\n";
   for (int counter = 1; counter <= 3; counter++)
   {
      cout << "Enter the number now: ";
      cin >> num;
      if (num == secret)
      {
         cout << "You guessed the secret number!";
         break;
      }
   }
   cout << "Program over";
   return 0;
 }


Criação de menu.

 #include <iostream>
 using namespace std; 
 int main ()
 {
   int  i;
   do
    {
       	cout << "\n\nEscolha a fruta pelo numero:\n\n";
       	cout << "\t(1)...Mamao\n";
       	cout << "\t(2)...Abacaxi\n";
       	cout << "\t(3)...Laranja\n\n";
       	cin >> i; 
    } while ((i<1)||(i>3));
   switch (i)
       {
       	case 1:
               	cout << ("\t\tVoce escolheu Mamao.\n");
       	      break;
       	case 2:
               	cout <<"\t\tVoce escolheu Abacaxi.\n";
       		break;
       	case 3:
               	cout << ("\t\tVoce escolheu Laranja.\n");
       		break;
        }
   return(0);
 }