Do while

Do while

O do while é um laço de repetição que executa primeiro o bloco de comandos e depois testa a condição. Caso a condição seja verdadeira, o laço é executado novamente. Quando a condição é falsa, a execução do laço é terminada.
Essa característica de executar e depois testar, garante que o laço será executado ao menos uma vez, diferentemente do while, o qual não executa quando sua condição é falsa.
A validação de entrada é um exemplo pertinente para o uso do do while, uma vez que a leitura do dado deverá ser executada ao menos uma vez. Quando o dado não é consistente com o conjunto de dados esperados, uma nova leitura é solicitada.
Veja o exemplo abaixo:



001:  #include <stdio.h>
002:  #include <stdlib.h>
003:
004:  int main(int argc, char * argv[])
005:  {
006:    char sexo;
007:
008:    do
009:    {
010:      printf("Digite o sexo: ");
011:      fflush(stdin); scanf("%c", &sexo);
012:      if(sexo != 'M' && sexo != 'F')
013:      {
014:        printf("Digite M ou F\n");
015:      }
016:    }while(sexo != 'M' && sexo != 'F');
017:    system("PAUSE");
018:    return 0;
019:  }



Note que o código é feito para importunar o usuário de forma que ele digite M para masculino ou F para feminino. Em outras palavras, o programa ficará em loop até que M ou F seja digitado. Baseado nisso, posso afirmar que a condição de saída do laço é M ou F.
Com este post finalizei a trilogia de laços de repetição, o que não quer dizer que esgotei o assunto...

While

Retomando o assunto Laços de Repetição, abordado em abril/2008, hoje vamos tratar do while.
A forma geral desse laço é:

while


while(condicao)
{
  comandos...
}


É importante saber que dentro do bloco de comandos do while é necessário tornar a condicao falsa. Caso isso não ocorra, o while entrará em loop infinito.

Vamos recorrer a um exemplo simples:
Suponha que uma cidade A possua 1.500.000 habitantes e taxa de crescimento anual de 1%. Suponha também que uma cidade B com 500.000 habitantes cresce anualmente a 3%. Você deseja saber em quantos anos, mantendo-se as taxas de crescimento, a população de B será maior que a população de A.


001:  #include <stdio.h>
002:  #include <stdlib.h>
003:
004:  int main(int argc, char * argv[])
005:  {
006:    int anos=0;
007:    float popA=1.5, popB = 0.5;
008:
009:    while(popA >= popB)
010:    {
011:      popA = 1.01 * popA;
012:      popB = 1.03 * popB;
013:      anos += 1;
014:    }
015:    printf(“Quantidade de anos necessaria: %d\n”, anos);
016:    system("PAUSE");
017:    return 0;
018:  }


O exemplo mostra que enquanto a condição for verdadeira, ou seja, a população de A for maior ou igual a B, os anos passam (linha 13), e a população cresce (linhas 11 e 12).
Os dados de população e taxa de crescimento possibilitam que em algum ano, a população da cidade B será maior que a de A.
Caso a taxa de crescimento de A fosse maior que a de B, nunca a condição de saída seria atingida.
Sempre que trabalhar com o while, verifique a condição e identifique quais linhas tornarão seu resultado falso e se isso acontecerá. Com essa verificação seu laço não entrará em loop infinito.
Agora farei algumas considerações com relação aos cálculos praticados nas linhas 11 e 12, os quais podem parecer obscuros a alguém.
A linha 11 poderia ser reescrita como:


popA = popA + 1.0/100 * popA;



Dividindo 1.0/100 temos:



popA = popA + 0.01 * popA;



Colocando popA em evidência temos:



popA = (1 + 0.01) * popA;



Efetuando a soma 1 + 0.01 fica:



popA = 1.01 * popA;



Bendita ou maldita matemática. :D

For

No tópico Laços de Repetição foram abordados de forma geral os três laços possíveis na linguagem C.
Esse tópico trata do laço for.
Como visto, a forma geral desse laço é:

for


for(variavel = valor_inicial; condicao_envolvendo_variavel; incremento/decremento de variavel)
{
  comandos...
}


Vamos vê-lo na prática:


001:  #include <stdio.h>
002:  #include <stdlib.h>
003:
004:  int main(int argc, char * argv[])
005:  {
006:    int i;
007:
008:    for(i = 0; i < 10; i++)
009:    {
010:      printf("%d\n", i);
011:    }
012:    system("PAUSE");
013:    return 0;
014:  }


O exemplo, embora simples, ilustra que o início do for é bem definido, bem como seu fim. Note que a variável i inicia com 0 e termina com 10.
Quando estou em sala de aula sempre pergunto quantas vezes o for será executado. A resposta é 10 vezes, com i variando de 0 a 9 (i < 10).
Se não confia em mim, execute o código acima e verifique as impressões do valor de i. Deverá aparecer 0, 1, ..., 9.
Outra pergunta que costumo fazer é qual o valor de i após a execução do laço for, em outras palavras, se imprimisse o valor de i na linha 012, o que seria impresso? A resposta correta é 10, lembre-se que existe uma condição para o for ser abandonado (i < 10). Quando i valer 10, o laço termina a sua execução.
Agora vamos ao exemplo prático. Vamos calcular o fatorial de um número inteiro.


001:  #include <stdio.h>
002:  #include <stdlib.h>
003:
004:  int main(int argc, char *argv[])
005:  {
006:    int fat = 1, n, i;
007:
008:    printf("Digite o numero: ");
009:    fflush(stdin); scanf("%d", &n);
010:
011:    if (n < 0)
012:    {
013:      printf("Nao existe fatorial de numero negativo.\n");
014:    }
015:    else
016:    {
017:        for(i = n; i > 1; i--)
018:        {
019:            fat *= i;
020:        }
021:        printf("%d! = %d\n", n, fat);
022:    }
023:    system("PAUSE");
024:    return 0;
025:  }


Verifique o início e o fim do laço, novamente bem definidos! Inicia em n e termina em 1.
A linguagem C permite que você altere, dentro do laço, os valores da variável de controle (i). Essa não é uma prática recomendável porque esse laço perde sua característica de executar um número determinado de vezes. Se você alterar os valores da variável de controle, não poderá garantir quantas vezes o laço será executado.

Laços de repetição

Os laços de repetição são ferramentas poderosas para o controle do fluxo de execução do programa. Eles permitem que um determinado trecho de código seja executado até que uma condição específica seja satisfeita.
A linguagem C possui três tipos de laço de repetição, a saber, o for (para), o while (enquanto) e o do while (faça enquanto).
O for deve ser utilizado quando você sabe o número de vezes em que o laço será executado. Por exemplo, o cálculo do fatorial de n, no qual sabe-se de antemão que o laço será executado n-1-vezes.
O while e o do while devem ser empregados quando não sabemos o número de vezes em que o laço será executado, por exemplo, quando pretende-se saber em quantos anos a população da cidade A será maior que a população da cidade B.
Existe uma particularidade entre o while e o do while. O bloco while pode nunca ser executado, caso a condição seja falsa logo na primeira tentativa. O do while executa o bloco e depois verifica a condição, portanto, ele será executado ao menos uma vez.
A forma geral de cada um dos laços é apresentada a seguir:

for


for(variavel = valor_inicial; condicao_envolvendo_variavel; incremento/decremento de variavel)
{
  comandos...
}



while


while(condicao)
{
  comandos...
  /*Não esqueça de que os comandos devem, de alguma forma, alterar condicao*/
}



do while


do
{
  comandos...
  /*Não esqueça de que os comandos devem, de alguma forma, alterar condicao*/
} while(condicao);



Nas estruturas while e o do while você deve alterar a condição, dentro do bloco, para que de alguma forma o laço tenha fim. Se isso não ocorrer, o programa entrará no chamado loop infinito.
Seu poder sobre o destino dos dados estão aumentando. Use-o com cautela.