A estrutura de repetição, ou simplesmente laço, permite que um grupo de
instruções seja executado repetidamente um número determinado de vezes ou até que uma
determinada condição se torne verdadeira ou falsa.
Veremos aqui as seguintes estruturas de repetição:
• a estrutura com teste no início: ENQUANTO - FAÇA
• a estrutura com teste no final: FAÇA - ENQUANTO
• a estrutura com variável de controle: PARA - PASSO - FAÇA
• a estrutura encadeada: constitui-se em uma combinação das anteriores
Uma característica importante a ser notada nos três primeiros tipos de estruturas de
repetição é que nos dois primeiros tipos (ENQUANTO - FAÇA e FAÇA - ENQUANTO), não
sabemos previamente o número de vezes que a repetição deverá ser executada e na terceira
estrutura (PARA - PASSO - FAÇA), necessitamos saber quantas vezes deverá ocorrer a
repetição.
As estruturas de repetição na Linguagem C são:
• a estrutura com teste no início: WHILE
• a estrutura com teste no final: DO-WHILE
• a estrutura com variável de controle: FOR
• a estrutura encadeada: constitui-se em uma combinação das anteriores
Estrutura de Repetição com Teste no Início: WHILE - DO
A estrutura de repetição, com teste no início,consiste em uma estrutura de controle do
fluxo lógico que permite executar diversas vezes uma mesma instrução ou um mesmo bloco de
instruções no algoritmo (bloco verdade), sempre verificando antes se o resultado da
é VERDADEIRO.
Nesta estrutura, a
instrução ou o bloco verdade é executado, retornando novamente à avaliação da
repetição da instrução ou do bloco verdade é feita enquanto a
VERDADEIRO.
Quando o resultado da
imediatamente posterior ao FIM-ENQUANTO será executado.
Ex1:
Crie um algoritmo que efetue a tabuada do número 5
// Programa: Exemplo 1
// Objetivo: Obter a tabuada do número cinco, utilizando a estrutura de
// repetição com teste no início.
// Dados de entrada: Nenhum dado de entrada é requerido.
// Dados de saída: a tabuada do número cinco
#include
#include
void main( )
{
int cont, //armazena o contador de repetição
resultado; // armazena o resultado da multiplicação
clrscr();
cont = 1;
while ( cont <= 10){ resultado = cont * 5; printf ("%d X 5 = %d \n", cont, resultado); cont ++; } getch();
Ex2:
Ler um número inteiro n, que não contém dígito 0, e escrever um número
inteiro m que corresponde ao número n invertido. Por exemplo, se n igual a 123, a saída será m
igual a 321.
// Programa: Exemplo 2
// Objetivo: Inverter um número inteiro sem dígito zero
// Dados de entrada: Um número inteiro e positivo n.
// Dados de saída: O número m ( n invertido)
#include
#include
void main( )
{
long int n, //armazena o número inteiro
r, // armazena um valor auxiliar
m; // armazena o número invertido
clrscr();
printf ("Entre com um número inteiro e positivo: ");
scanf("%ld", &n);
m = 0; // inicializa a variável que conterá o inteiro invertido
while ( n > 0){
r = n % 10;
m = m*10 + r;
n = n/10;
}
printf ("O numero invertido = %ld \n", m);
getch();
}
Ex3:
Uma pesquisa sobre algumas características físicas da população de uma
determinada região coletou os seguintes dados, referentes a cada habitante, para serem
analisados:
• idade em anos
• sexo (masculino, feminino)
• cor dos olhos (azuis, verdes, castanhos)
• cor dos cabelos (louros, castanhos, pretos)
Para cada habitante são informados os quatro dados acima. A fim de indicar o final
da entrada, após a seqüência de dados dos habitantes, o usuário entrará com o valor -1 para a
idade, o que deve ser interpretado pelo algoritmo como fim de entrada.
Encontrar a maior idade de um conjunto de indivíduos e o percentual de indivíduos
do sexo feminino com idade entre 18 e 35 anos, inclusive, e olhos verdes e cabelos louros.
Resolução:
Neste exemplo não sabemos quantos habitantes serão processados, entretanto, o
problema diz que a entrada encerra quando for digitado o número –1 ao invés de uma idade, o
que nos possibilita utilizar uma estrutura do tipo ENQUANTO - FAÇA para ler a entrada.
Quanto a idade, observe que, ao invés de lermos o primeiro habitante separadamente
para inicializarmos o valor da variável maioridade com a idade do primeiro habitante, usamos
um número negativo. Neste caso, isso é possível, pois não existe um valor de idade negativo e,
além disso, quando maioridade for comparada com a idade do primeiro habitante, ela sempre
vai receber este valor, pois ele sempre será maior do que o valor negativo de maioridade.
Finalmente, o algoritmo calcula a porcentagem pedida de habitantes e escreve os
resultados dentro de uma estrutura condicional SE – ENTÃO. Isto é necessário para evitar que o
cálculo de porcentagem seja realizado com o valor de totalhabitantes igual a 0, o que seria
uma instrução impossível de ser executada.
// Programa: Exemplo 3
// Objetivo: Encontrar a maior idade de um conjunto de indivíduos e o
// percentual de indivíduos do sexo feminino com idade entre 18 e 35
// anos, inclusive, e olhos verdes e cabelos louros
// Dados de entrada: a idade, o sexo, a cor dos olhos e dos cabelos.
// Dados de saída: a maior idade maioridade, e o percentual, porcentagem,
// indivíduos do sexo feminino com idade entre 18 e 35 anos
#include
#include
void main(void )
{
int idade, maioridade, habitantes, totalhabitantes, porcentagem;
char sexo, olhos, cabelos;
clrscr();
maioridade = -1;
habitantes = totalhabitantes = 0;
printf ("Entre com a idade do habitante ou –1 para encerrar: ");
scanf("%d", &idade);
while ( idade != -1 )
{
printf ("Entre com o sexo do habitante: ");
scanf("%c", sexo);
printf ("\n Entre com a cor dos olhos do habitante: ");
scanf("%c", olhos);
printf ("\n Entre com a cor dos cabelos do habitante: ");
scanf("%c", cabelos);
if (idade > maioridade)
maioridade = idade;
totalhabitantes ++;
if ((idade >=18) && (idade <= 35) && sexo ==’F’) && (olhos ==’V’) && (cabelos ==’L’)) habitantes ++;
printf ("Entre com a idade do habitante ou –1 para encerrar: ");
scanf("%d", &idade); }
if (totalhabitantes > 0)
{
porcentagem = habitantes*100/totalhabitantes;
printf ("A maior idade = %d\n", maioridade);
printf ("A porcentagem = %d %%", porcentagem);
}
getch();
}
Estrutura de Repetição com Teste no Final: DO - WHILE
A estrutura de repetição com teste no final é semelhante à estrutura anterior, pois esta
também é utilizada quando não sabemos antecipadamente o número de repetições a ser
executada.
A característica principal desta estrutura é que a instrução ou o bloco verdade é
executado pelo menos uma vez, independentemente do resultado da
Nesta estrutura de repetição executa-se a instrução ou o bloco verdade e somente ao
final desta execução a
então se executa novamente a instrução ou o bloco verdade, até que o resultado da
seja FALSO, isto é, enquanto a
instruções serão executados. Caso contrário, a instrução ou bloco de instruções imediatamente
posterior à estrutura de repetição é executada.
Ex4:
Dado um número inteiro e positivo, calcular o seu fatorial. Fatorial é o
produto dos números naturais desde 1 até o inteiro n.
Resolução:
O cálculo de um fatorial é conseguido pela multiplicação sucessiva do número de
termos. Sabendo que:
N ! = 1 x 2 x 3 x 4 x 5 x. ... x (N-1) x N.
0 ! = 1, por definição.
No caso de n = 5, o programa deverá executar as multiplicações sucessivas e
acumulá-las a fim de possuir o valor 120 após 5 passos. O número de passos deverá ser
controlado pela variável i.
// Programa: Exemplo 1
// Objetivo: Calcular o fatorial de um número inteiro.
// Dados de Entrada: O valor de um número natural n.
// Dados de Saída: O fatorial do número n na variável fatorial.
#include
#include
void main(void )
{
int n; // armazena o número natural n
long int fatorial; // armazena o valor do fatorial
int cont; // armazena o contador
clrscr ( );
printf ("Deseja calcular o fatorial do número: " );
scanf ("%d", &n); // lê o numero n
fatorial = 1; // inicializa a variável que irá armazenar o valor do fatorial
cont = 1; // inicializa a variável contador
do // calcula a fatorial
{
fatorial = fatorial * cont;
cont = cont + 1;
}
while (cont <= n); printf ("\n O fatorial de %d é: %ld\n", n, fatorial ); //imprime o fatorial getch (); }
Estrutura de Repetição com Variável de Controle: FOR
A estrutura de repetição com variável de controle permite que uma instrução ou bloco
verdade seja executado repetidamente por um número definido de vezes, pois os limites
são fixos.
Então, a característica principal deste tipo de estrutura é que se deve saber previamente
o número de vezes que a instrução ou bloco verdade deve ser repetido.
O comando FOR é composto pela inicialização, por uma condição e por um
incremento.
A inicialização é uma declaração de atribuição usada para inicializar a variável de
controle do laço por um valor inicial. É sempre executada uma única vez antes do laço ser
iniciado.
A condição é geralmente uma expressão lógica que determina quando o laço
terminará pelo teste da variável de controle do laço contra algum valor.
O incremento define como a variável de controle do laço mudará cada vez que a
repetição for realizada. Esta instrução é executada toda vez imediatamente após a execução do
corpo do laço.
Podemos ver que o FOR executa a inicialização incondicionalmente e testa a
condição. Se a condição for FALSA, a execução do programa continuará na próxima instrução
depois da estrutura FOR.
Se a condição for VERDADEIRA ele executa a instrução ou bloco de instruções, faz
o incremento e volta a testar a condição. Ele fica repetindo estas operações até que a condição
seja FALSA.
O melhor modo de se entender o loop FOR é ver como ele funciona "por dentro". O
laço ou loop FOR é equivalente a se fazer o seguinte:
variavel = valor inicial;
while ( condição)
{ // início do bloco verdade
instrução 1;
instrução 2;
.
instrução n;
incremento;
} // fim do bloco verdade
Ex5:
Uma pessoa aplicou seu capital a juros e deseja saber, trimestralmente, a
posição de seu investimento inicial c. Chamando de i a taxa de juros do trimestre, escrever uma
tabela que forneça, para cada trimestre, o rendimento auferido e o saldo acumulado durante o
período de x anos, supondo que nenhuma retirada tenha sido feita.
// Programa: Exemplo 5
// Objetivo: Calcular o rendimento trimestral de valor aplicado.
// Dados de Entrada: O capital c, a taxa de juros i e o número de anos.
// Dados de Saída: O rendimento trimestral r e o montante c tabulados.
#include
#include
void main(void )
{
float c, // investimento inicial
r; // rendimentos
int i, // taxa de juros
x, // número de anos
n, // número de trimestres
j; // contador
clrscr ();
printf (“\n Digite o investimento inicial: “);
scanf (“%f”, &c); //lê o capital inicial
printf (“\n Digite a taxa de juros: “);
scanf (“%d”, &i); //lê a taxa de juros
printf (“\n Digite o numero de anos: “);
scanf (“%d”, &x); //lê números de anos
n = x * 4; //calcula o número de trimestres em x anos
for ( j = 1; j<= n; j ++) //calcula e exibe rendimento e montante
{ r = i * c; c = c + r;
printf (“\n Rendimento do trimestre %d e’ de %.2f ", j, r);
printf (“\n Montante do trimestre %d e’ de %.2f” , j, c);
}
getch (); }
O algoritmo inicia com o cálculo do número de trimestres em x anos, já que o
rendimento deve ser calculado por trimestre e a taxa de juros i também é dada em função do
número de trimestres. A estrutura "for" é repetida n vezes, onde n é o
número de trimestres encontrado. A cada repetição, o rendimento r é calculado e o capital c é
somado a r para totalizar o montante do mês. Em seguida, os valores de r e c são exibidos para o
usuário.
Estrutura de Repetição Encadeada
Assim como as estruturas de seleção, as estruturas de repetição também podem
conter o encadeamento de um tipo de estrutura de repetição com outro tipo de estrutura de
repetição. A existência destas ocorrências vai depender do problema a ser resolvido.
Ex6:
Calcular o fatorial de um número inteiro qualquer. Calcular outros
fatoriais até que o usuário não mais deseje utilizar o algoritmo. Sendo assim, o algoritmo deverá
pedir ao usuário a sua continuidade ou não.
// Programa: Exemplo 6
// Objetivo: Calcular o fatorial de um número inteiro.
// Dados de Entrada: O valor de um número natural n.
// Dados de Saída: O fatorial do número n na variável fatorial.
#include
#include
void main(void )
{
int n, // armazena o número natural n
cont; // armazena o contador
long int fatorial; // armazena o valor do fatorial
char resp; //para confirmação da continuidade do algoritmo
clrscr ();
resp = 'S';
while (resp != 'N')
{
fatorial = 1;
printf ("\n Fatorial de que número? “);
scanf (“%d ", &n);
for (cont = 1; cont <= n; cont ++) //calcula a fatorial fatorial = fatorial * cont;
printf (“O fatorial de %d e’ %ld \n", n, fatorial );
printf ("Deseja continuar (S/N): “);
resp = getche(); } getch(); }
