[WAGS] Capítulo 3 - Laços

Prévia do material em texto

CAPITULO 3 – LAÇOS
Laços são comandos usados sempre que uma ou mais instruções tiverem de ser repetidas enquanto uma certa condição estiver sendo satisfeita. Em C existem 3 de laços:
	for
	while
	do-while
O LAÇO for
O laço for geralmente é usado quando queremos repetir uma instrução por um número fixo de vezes.
Isso ignifica que utilizamos um laço for quando sabemos de antemão o número de vezes a se repetir uma instrução.
· Sintaxe do Laço for
A sintaxe consiste na palavra chave for seguida de parênteses que contêm 3 expressões separadas por ponto-e-vírgulas.
Chamaremos a primeira dessas expressões de Inicialização a segunda de Teste e a terceira de Incremento. Qualquer uma delas pode conter qualquer instrução válida em C.
for (inicialização ; teste ; incremento) {}
for (size_t i = 0; i < count; i++)
{
    /* code */
}
A Inicialização é uma instrução de atribuição (i = 0) e é sempre executada uma única vez, antes que o laço seja iniciado.
O Teste é uma condição avaliada como verdadeira ou falsa, e controla o laço (i < 20).
Essa expressão é avaliada toda vez que o laço é iniciado ou reiniciado. Se verdadeira (diferente de zero), a instrução do corpo do laço é executada. Quando o teste se torna falso (igual a zero), o laço é encerrado e o controle passa para a instrução seguinte ao laço.
O Incremento geralmente define a maneira pela qual a variável de controle será alterada cada vez que o laço for repetido (i++). Essa expressão sempre é executada logo após a execução do corpo do laço.
Exemplo: 		Programa para imprimir uma tabuada invertida
    for (int i = 9; i > 0; i--)
    {
        printf("%d x 6 = %d\n", i, i * 6);
    }
Saída:
9 x 6 = 54
8 x 6 = 48
7 x 6 = 42
6 x 6 = 36
5 x 6 = 30
4 x 6 = 24
3 x 6 = 18
2 x 6 = 12
1 x 6 = 6
Exemplo: 		Imprimir todos os múltiplos de 3 entre 3 a 100
for (int i = 3; i < 100; i+=3)
    {
        printf("%d\t", i);
    }
Saída:
 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45 48 51 54 57 60 63 66 69 72 75 78 81 84 87 90 93 96 99
· Flexibilidade do laço for
Nos exemplos anteriores, utilizamos o laço for na sua forma mais simples.
Isto é, a primeira expressão para inicializar a variável, a segunda para expressar um limite e a terceira para incrementar ou decrementar a variável.
Entretanto, as expressões não estão restritas a essas formas. Exemplos de outras possibilidades são mostrados a seguir.
· O operador vírgula
Qualquer uma das expressões (inicialização, limite, incrementação/decrementação) de um laço for pode conter várias instruções separadas por vírgulas.
A vírgula, nesse caso, é um operador C que significa “faça isso e depois isso”. Um par de expressões separadas por vírgula é avaliado da esquerda para a direita.
Exemplo:
{
    int i, j;
    for (i = 0, j = 0; i + j < 100; ++i, ++j)
    {
        printf("%d\t", i + j);         // Imprime todos os números de 0a98 de 2em2.
    }
}
Saída:
 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 96 98
· Usando caracteres
A variável do laço pode ser do tipo char. Veja um exemplo:
Exemplo:
    for (char ch = 'a'; ch < 'z'; ++ch)
    {
        printf("O valor ASCII de %c eh %d\n", ch, ch);
    }
Saída:
O valor ASCII de a eh 97
O valor ASCII de b eh 98
...
O valor ASCII de x eh 120
O valor ASCII de y eh 121
· Usando chamadas a funções
É possível chamar funções de dentro de expressões do laço for.
Exemplo:
    for (char ch = getch(); ch != 'X'; ch = getch())
    {
        printf("%c\n", ch + 1);
    }
Saída:
Esse programa lê caractere a caractere do teclado e imprime o caractere seguinte da tabela ASCII.
O programa acaba quando o usuário digita “X”.
· Omitindo expressões do laço for
Qualquer uma das três expressões de um laço for pode ser omitida, embora os pontos-e-vírgulas devam permanecer.
Se a expressão de inicialização ou a de incremento for omitida, será simplesmente desconsiderada. Se a condição de teste não estiver presente, será considerada permanentemente verdadeira.
Exemplo:
 char ch;
      for ( ; (ch = getch()) != 'X' ; )
            {
             printf("%c", ch + 1);
            }
Saída:
Esse programa lê caractere a caractere do teclado e imprime o caractere seguinte da tabela ASCII.
O programa acaba quando o usuário digita “X”.
Colocamos parênteses extras envolvendo a expressão de atribuição (ch = getch()).
Esses parênteses são realmente necessários, pois a precedência de != é maior que a de =; isso significa que, na falta dos parênteses, o teste relacional != será feito antes da atribuição.
VISIBILIDADE DE VARIÁVEIS DE BLOCO
Um aspecto importante dos blocos de código é o de que uma variável declarada dentro de um bloco não é visível fora dele.
No programa abaixo, declaramos a variável nota dentro do bloco de código do laço for. Essa variável só pode ser acessada pelas instruções desse mesmo bloco e pelas que estão escritas após sua declaração.
Exemplo:
{
    int soma = 0, i;
    for (i = 0; i < 4; i++)
    {
        float nota;
        printf("Entre com a nota %d: ", i + 1);
        scanf("%f", &nota);
        soma += nota;
    }
    printf("MEDIA = %.2f", (float)soma / 4);
    printf("%f", nota);                 // Erro de "undeclared" variável
}
Saída:
Entre com a nota 1: 5
Entre com a nota 2: 6
Entre com a nota 3: 5
Entre com a nota 4: 6
MEDIA = 5.50
· Criando blocos dentro de blocos
Em todo lugar onde é possível colocar uma instrução C, é também possível inserir um bloco de código.
Exemplo:
{
    int i = 5;
    {
        int i = 150;
        printf("%d\n", i);
    }			// Destruição da variável i
    printf("%d", i);
}
Observe a variável i do bloco interno no programa. Essa é uma nova variável com o mesmo nome da variável criada no bloco da função main().
Ela é criada quando o bloco inicia sua execução e é destruída quando o bloco termina. Assim, a instrução após o fim do bloco utiliza a variável i do bloco de main(), pois a outra não mais existe.
Saída:
150
5
· Laços for aninhados
Quando um laço for faz parte do corpo de outro laço for, dizemos que o laço interno está aninhado.
Para mostrar esse uso, preparamos um programa que imprime as tabuadas do 2 ao 9.
Exemplo:
{
    int i, j;
    for (j = 2; j < 10; j++)
    {
        printf("TABUADA DO %d\n", j);
        for (i = 1; i < 11; i++)
        {
            printf("%d x %d = %d\n", j, i, j * i);
        }
        printf("\n");
        }    
}
Saída:
TABUADA DO 2
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
[...]
9 x 7 = 63
9 x 8 = 72
9 x 9 = 81
9 x 10 = 90
O LAÇO while
Utilizamos o laço while quando o laço pode ser terminado inesperadamente, por condições desenvolvidas dentro do corpo do laço.
O programa aguarda a digitação de uma frase. Cada caractere digitado é contado e acumulado na variável cont até que a tecla [ENTER] seja pressionada. O programa imprime o total de caracteres da frase.
Exemplo:
{
    int cont = 0;
    while (getche() != '\r')
    {
        cont++;
        printf("\t%d\n", cont);
    }
    printf("A palavra tem %d letras.", cont);
}
Saída:
t 1
e 2
s 3
t 4
e 5
A palavra tem 5 letras.
O laço while é utilizado principalmente quando não conhecemos de antemão o número de interações que serão executadas.
Em situações em que o número de iterações é conhecido, o laço for é a escolha mais natural.
· Sintaxe do laço while
O comando while consiste na palavra-chave while seguida de uma expressão de teste entre parênteses.
Se a expressão de teste for verdadeira, o corpo do laço é executado uma vez e a expressão de teste é avaliada novamente. Esse ciclo de teste e execução é repetido até que a expressãode teste se torne falsa (igual a zero), então o laço termina e o controle do programa passa para a linha seguinte ao laço.
    while (/* condition */)
    {
        /* code */
    }
· Laços while aninhados
Uma das instruções de um bloco de código que compõe o corpo de um laço while pode ser outro laço while (aninhados).
Considere o seguinte programa que testa a sua capacidade de adivinhar uma letra minúscula entre “a” e “z”.
Exemplo:
{
    char ch = 's';
    char resp;
    char secreto;
    int tentativas;
    while (ch == 's')
    {
        secreto = (rand() % 26 )+ 'a';
        tentativas = 1;
        printf("Digite uma letra de 'a' a 'z': ");
        while ((resp = getch()) != secreto)
        {
            printf("%c eh incorreto. Tente novamente\n", resp);
            tentativas++;
        }
        printf("%c eh correto!\n", resp);
        printf("Voce acertou em %d tentativas\n", tentativas);
        printf("Quer jogar novamente? \n");
        ch = getche();        
    }    
}
Saída:
Digite uma letra de 'a' a 'z':
a eh incorreto. Tente novamente
s eh incorreto. Tente novamente
d eh incorreto. Tente novamente
k eh incorreto. Tente novamente
f eh incorreto. Tente novamente
l eh incorreto. Tente novamente
g eh incorreto. Tente novamente
o eh incorreto. Tente novamente
h eh correto!
Voce acertou em 9 tentativas
Quer jogar novamente?
· A função rand()
Na instrução
secreto = (rand() % 26 )+ 'a';
do programa anterior, utilizamos uma nova função de biblioteca C, a função rand(),
que necessita da inclusão do arquivo <stdlib.h>.
Essa função retorna um número inteiro aleatório (sorteado).
A expressão rand() % 26 resulta o resto da divisão do valor de rand() por 26. O resultado é um número entre 0 e 25. A este número é somado o caractere ‘a’ para gerar uma letra sempre minúscula aleatória.
O LAÇO do-while
O terceiro e último comando de laço em C é o laço do-while.
Ele é utilizado em situações em que é necessário executar o corpo do laço ao menos uma vez e, depois, avaliar a expressão de teste e criar um ciclo repetido.
· Sintaxe do laço do-while
    do
    {
        /* instrução 1 */
        /* instrução 2 */
    } while (/* expressão de teste */);  
Primeiramente, o bloco de código é executado; em seguida, a expressão de teste entre parênteses é avaliada; se verdadeira, o corpo do laço é mais uma vez executado e a expressão de teste é avaliada novamente.
Esse ciclo de execução do bloco e teste é repetido até que a expressão de teste se torne falsa (igual a zero), quando o laço termina e o controle do programa passa para a linha seguinte ao laço.
Um bom exemplo do uso de um laço do-while é o programa escrito anteriormente. Nesse programa, queremos que o usuário jogue uma primeira vez para, depois, perguntarmos se ele deseja jogar novamente.
Exemplo:
{
    char secreto;
    char resp;
    int tentativas;
    do {
        secreto = (rand() % 26) + 'a';
        tentativas = 1;
        printf("\nDigite um letra entre 'a' e 'z'\n");
        while ((resp = getch()) != secreto)
        {
            printf("%c eh incorreto. Tente novamente.\n", resp);
            tentativas++;
        }
        printf("%c eh correto!\n", resp);
        printf("Voce acertou em %d tentativas\n", tentativas);
        printf("Quer jogar novamente? (s/n): ");      
    } while (getche() == 's');
    printf("\nAte logo. Boa sorte!\n");
}
Saída:
Digite um letra entre 'a' e 'z'
i eh incorreto. Tente novamente.
o eh incorreto. Tente novamente.
p eh correto!
Voce acertou em 3 tentativas
Quer jogar novamente? (s/n):
Perceba que nessa versão, não é mais necessária a variável ch, presente na primeira versão do while.
· Quando usar do-while
Existe uma estimativa que aponta os laços do-while necessários somente em 5% dos laços.
Várias razões influem na consideração de laços que avaliam a expressão de teste antes de serem executados como superiores. Uma delas é a legibilidade, isto é, ler a expressão de teste antes de percorrer o laço ajuda o leitor a interpretar facilmente o sentido do bloco de instruções.