Programar em C++/Estruturas de repetição
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
editarO 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
editarwhile (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
editarO 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
editardo {
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
editarComo 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
editarfor ([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
editarBloco de Comandos
editarEm 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
editarO 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
- include<iostream>
- include<stdio.h>
int main() { int a[10], i;
for(i=0;i<10;i++) a[i]=i+i;
} Identifique os valores das iterações abaixo: O valor do elemento x[3] é ___. O valor do elemento x[9] é ___.
Incrementar/decrementar
editarAqui 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
editarCrie 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);
}