Existem situações onde é necessário repetir um determinado tracho de um programa um número de vezes. Isto pode ser conseguido de duas formas: a primeira, onde será escrito o mesmo trecho tantas vezes quanto necessário, um tanto trabalhoso e a segunda forma onde poderá ser utlizado o conceito de looping. Os loopings são conhecidos também por laços ou malhas.

Comando for

Comando while

Comandos do while

5.1. Comando for

Os loopings que possuem um número finito de execuções poderão ser processados através do looping do tipo for. Este tipo de looping tem seu funcionamento controlado por uma variável de controle do tipo contador, podendo ser crescente ou decrescente.

sintaxe: for (início;fim;incremento)
instruções1;

Caso venha existir mais de uma instrução para ser executada dentro do looping, estas deverão estar inseridas em um bloco.

for (início;fim;incremento)
{
 	instruções1;
	instruções2;
	instruções3;
}

Partes do comando for são opcionais

O laço for usa três seções dentro do comando for: uma inicialização, um teste e um incremento.

for (inicialização; teste; incremento)

Se você já atribuiu o valor 0 à variável conta, pode pular a seção de inicialização do laço. Depois para exibir os números de 0 até 99, seu laço conterá o seguinte:

for (; conta<100;conta++)
   printf(" %d", conta);

No entanto, se você omitir uma das seções do laço for, precisa incluir o ponto-e-vírgula correspondente. Por exemplo, o laço for a seguir omite as seções de inicialização e incremento.

for (; conta<100;)
    printf(" %d", conta++);

Da mesma forma, o comando for a seguir ficará em execução perpetuamente:

for (;;)
// comando;

Controlando o Incremento do Laço for

Por exemplo, o seguinte comando for incrementa a variável de controle contador por 10 a cada iteração do laço:

for (contador=0;contador<=100; contador+=10)
   printf(" %d\n", contador);

Usando laços for com valores char e float

Você pode usar caracteres e valores em ponto flutuante nos seus laços for. Por exemplo, o seguinte laço for exibe as letras do alfabeto:

for (letra='A';letra<='Z'; letra++)
    printf("%c", letra);

Da mesma forma, o laço a seguir incrementa um valor de ponto flutuante em 0.5;

for (porcent=0.0;porcent<=100.0; porcent+=0.5)
    printf(" %f\n", porcent);

Compreendendo um Laço NULL

No passado, quando os programadores queriam que seus programas fizessem uma breve pausa, talvez para exibir alguma mensagem, eles colocavam um laço NULO ou "não faz nada" em seus programas. Por exemplo, a seguir o laço for não faz nada 10 vezes:

for (contador=1;contador<=100; contador+=10)
    ; // Não faz nada 

Compreendendo o Laço Infinito

Quando você usa laços for, precisa garantir que o laço atenderá a sua condição final. Caso contrário, o laço continuará sua execução para sempre. Esses laços intermináveis são chamados laços infinitos. Na maioria dos casos, os laços infinitos ocorrem como resultado de erro na programação. Por exemplo:

for (i=0;i<100; i++)
{
   printf(" %d", i);
   resultado = valor * --i;    // causa do erro
}

Como você pode ver, o segundo comando do laço decrementa o valor para -1, e, depois incrementa o valor para 0. Como resultado, o valor nunca atinge 100, de modo que o laço não termina. Quando seu programa entra em um laço infinito, talvez você possa pressionar Ctrl+C para finalizar o programa.

Evite modificar o valor de uma variável de um Laço FOR

Já vimos que o comando for lhe permite repetir um ou mais comandos um número específico de vezes. Para efetuar esse processamento, o laço for usa uma variável de controle, que funciona como um contador. Como regra, você não deve alterar o valor de uma variável de controle no comando do laço for. O único local onde o valor da variável de controle deve ser alterado é nas seções de inicialização e incremento do laço for. Ao alterar o valor da variável de controle nos comandos do programa, você corre o grande risco de criar um laço infinito, tornando seus programas mais difíceis de ser compreendidos. No entanto algumas vezes, você pode querer que o laço termine ou pule a iteração atual quando a variável de controle for igual a um certo valor. Em tais casos, use o comando break ou continue, discutidos em detalhes em outras dicas desta seção.

5.2. Comando while

Esta estrutura de looping caracteriza-se por efetuar um teste lógico no início de um looping, verificando se é permitido executar o trecho de instruções subordinados a este. A estrutura while tem seu funcionamento controlado por condição. Desta forma, poderá executar um determinado conjunto de instruções enquanto a condição verificada permanecer verdadeira. No momento em que esta condição se torna falsa, o processamento da rotina é desviado para fora do looping. Sendo a condição falsa logo no início do looping, as instruções contidas neste são ignoradas. Caso seja necessário executar mais de uma instrução para uma condição verdadeira dentro do looping, estas deverão estar mencionadas dentro de um bloco definido com { e }.

sintaxe:

while (condição)
{
    // instruções para condição verdadeira

}

exemplo:

O programa a seguir, usa o laço while para repetir um laço até que você pressione a tecla S ou N em resposta a uma pergunta.

#include <stdio.h>
#include <ctype.h>
#include <conio.h>
void main(void)
{
   char letra; // letra digitada pelo usuário 
   printf("Quer continuar? (S/N): ");
   letra= getch(); // lê a letra
   letra = toupper(letra); // converte a letra para maiúscula
   while ((letra!='S') && (letra!='N'))
   {  
       putch(7); // soa o alto-falante
       letra= getch(); // lê a letra
       letra = toupper(letra); // converte a letra para maiúscula
   }
   printf("\nSua resposta foi %c\n", letra);
}

5.3. Comando do while

Esta estrutura do while caracteriza-se por efetuar um teste lógico no final de um looping, sendo parecida com a estrutura while. Seu funcionamento também é controlado por decisão. Este tipo de looping irá efetuar a execução de um conjunto de instruções pelo menos uma vez antes de verificar a validade da condição estabelecida. Diferente da estrutura while que executa somente um conjunto de instruções enquanto a condição é verdadeira. Desta forma do while irá processar um conjunto de instruções, no mínimo uma vez até que a condição se torne falsa.

sintaxe:

do
{
   // instrução1 até que a condição seja verdadeira;
   // instrução2 até que a condição seja verdadeira;
   // instruçãoN até que a condição seja verdadeira;
}while (condição);

exemplo:

O programa a seguir, usa o laço do while para repetir um laço até que você pressione a tecla S ou N em resposta a uma pergunta.

#include <stdio.h>
#include <ctype.h>
#include <conio.h>
void main(void)
{
   char letra; // letra digitada pelo usuário
   printf("Quer continuar? (S/N): ");
   do
   {
     letra= getch(); // lê a letra
     letra = toupper(letra); // converte a letra para maiúscula
     if (letra!='S') && (letra!='N')
        putch(7); // soa o alarme - caractere inválido
   }while((letra!='S') && (letra!='N'));
}