❧ Repetições ❧

Repetições6.1

Este capítulo tem como objetivo fundamental apresentar o funcionamento de cada uma das estruturas de repetição disponíveis na linguagem C. Ao longo deste estudo, você desenvolverá as competências necessárias para manipular o fluxo de execução de seus programas de forma eficiente. Ao final da leitura, você será capaz de compreender e definir o conceito de um laço (loop), identificar e prevenir a ocorrência de um laço infinito, além de dominar a utilização prática dos comandos while, for (incluindo a técnica de omissão de cláusulas) e do-while. Adicionalmente, você aprenderá a estruturar o aninhamento de repetições e a controlar o fluxo interno desses ciclos utilizando os comandos de interrupção e salto break e continue.

Repetição por Condição6.2

Nas etapas anteriores, você aprendeu a utilizar os desvios condicionais para garantir que um bloco de comandos fosse executado apenas quando uma condição específica fosse atendida. Contudo, em diversas situações de programação, surge a necessidade de que um bloco de instruções não seja executado apenas uma única vez, mas sim repetidamente, enquanto uma determinada condição permanecer verdadeira.

A lógica fundamental dessa estrutura pode ser resumida pelo conceito: "enquanto uma condição for válida, faça a sequência de comandos". Esse processo cria um ciclo que se encerra somente quando a condição avaliada se torna falsa.

Essa dinâmica é muito semelhante ao funcionamento de um fluxograma. Neles, utilizamos o símbolo do losango para decidir entre diferentes caminhos baseados em uma resposta do tipo verdadeiro ou falso. A diferença fundamental na estrutura de repetição é que, ao atingir o final da sequência de comandos, o fluxo do programa não segue adiante, mas é desviado novamente para o ponto de avaliação da condição, reiniciando o processo.

Laço infinito6.3

Um laço infinito (infinite loop) caracteriza-se por uma sequência de comandos que se repete indefinidamente durante a execução de um programa. Essa situação é, na maioria das vezes, fruto de um erro de lógica ou de programação e ocorre principalmente por dois motivos fundamentais:

• Ausência de uma condição de parada: Você não define um critério que interrompa o ciclo de repetição.
• Condição de parada inalcançável: Existe um critério de interrupção, mas, devido à lógica do código, ele nunca é satisfeito.

Essencialmente, o laço infinito surge de falhas ao especificar a expressão condicional que controla a estrutura de repetição.

Exemplo: Condição Errônea6.3.1

No cenário ilustrado abaixo, você pode observar um erro na lógica de atualização da variável de controle:

X recebe 4;
enquanto (X < 5) faca
    X recebe X – 1;
    Imprima X;
fim enquanto

Neste código, a variável $X$ inicia com o valor 4 e a repetição continua enquanto $X < 5$. No entanto, a instrução interna subtrai uma unidade de $X$ a cada iteração ($X = X - 1$). Como o valor de $X$ torna-se cada vez menor e mais negativo, a condição $X < 5$ será permanentemente verdadeira, impedindo que você saia do laço.

Exemplo: Ausência de Modificação de Valor6.3.2

Outro erro frequente que produz um laço infinito é a omissão de comandos que alterem o estado das variáveis de controle dentro do bloco de repetição:

X recebe 4;
enquanto (X < 5) faca
    Imprima X;
fim enquanto

Como demonstrado acima, você define o valor de $X$ como 4 e a condição de entrada como $X < 5$. Contudo, não existe nenhuma instrução dentro do laço que modifique o conteúdo de $X$. Dessa forma, a condição permanece eternamente verdadeira, fazendo com que o programa imprima o valor de $X$ sem nunca encerrar a execução.

Comando while6.4

O comando while é a implementação direta na linguagem C da estrutura de repetição por condição "enquanto". Ele permite que um bloco de código seja executado repetidamente enquanto uma expressão lógica for considerada válida.

A forma geral do comando é:

while (condição) {
    sequência de comandos;
}

Durante a execução, o funcionamento do while segue este fluxo lógico:

• Avaliação da Condição: O programa testa a expressão entre parênteses.
• Condição Verdadeira: Se o resultado for diferente de zero, a sequência de comandos interna é processada. Após a execução da última instrução do bloco, o fluxo retorna automaticamente ao teste da condição para uma nova validação.
• Condição Falsa: Se o resultado for igual a zero, o bloco de comandos é ignorado e o programa segue para a instrução imediatamente após o fechamento das chaves.

O exemplo abaixo demonstra um programa que solicita dois números inteiros ao usuário e imprime todos os valores existentes entre eles:

#include <stdio.h>
#include <stdlib.h>

int main(){
    int a, b;
    printf("Digite o valor de a: ");
    scanf("%d", &a);
    printf("Digite o valor de b: ");
    scanf("%d", &b);

    while (a < b){
        a = a + 1;
        printf("%d \n", a);
    }

    system("pause");
    return 0;
}

Regras de Sintaxe e Boas Práticas6.4.1

Assim como você aprendeu no estudo do comando if, o while compartilha diversas regras estruturais essenciais:

• Expressões Lógicas: A condição pode ser qualquer expressão que utilize operadores matemáticos, relacionais ou lógicos, desde que resulte em um valor falso (zero) ou verdadeiro (diferente de zero).
• Uso de Chaves: O comando atua apenas sobre a instrução imediatamente seguinte. Para executar um conjunto de comandos, você deve obrigatoriamente delimitá-los entre chaves { }.
• Ponto e Vírgula: Nunca utilize o ponto e vírgula (;) logo após a condição.

while (a < b); { // ERRADO! O ponto e vírgula interrompe o laço.
    a = a + 1;   // Este comando agora está FORA do while.
    printf("%d \n", a);
}

Lembre-se: é sua total responsabilidade como programador garantir que o valor de algum elemento da condição seja modificado dentro do bloco de comandos, assegurando que o programa eventualmente atinja a condição de parada.

Comando for6.5

O comando for possui uma funcionalidade muito similar ao while, sendo projetado para repetir um comando ou um bloco de instruções diversas vezes. Sua principal característica é a capacidade de condensar a inicialização, a condição de parada e a atualização das variáveis em uma única linha.

A forma geral do comando é:

for (inicialização; condição; incremento) {
    sequência de comandos;
}

Durante a execução deste laço, você deve observar a seguinte sequência de passos:

• Inicialização: Esta cláusula é executada apenas uma vez, no início do processo. Nela, você atribui valores iniciais às variáveis que controlam o laço.
• Teste de Condição: Antes de cada repetição, a expressão lógica é avaliada.
  • Se for verdadeira (valor diferente de zero), o bloco de comandos interno é executado.
  • Se for falsa (zero), o laço é encerrado imediatamente.
• Incremento: Após a execução dos comandos internos, o programa executa a etapa de incremento ou atualização das variáveis. Finalizada esta etapa, o fluxo retorna ao teste de condição.

O código abaixo exemplifica o uso do for para imprimir todos os números inteiros entre dois valores, a e b, fornecidos por você:

#include <stdio.h>
#include <stdlib.h>

int main(){
    int a, b, c;
    printf("Digite o valor de a: ");
    scanf("%d", &a);
    printf("Digite o valor de b: ");
    scanf("%d", &b);

    for (c = a; c <= b; c++){
        printf("%d \n", c);
    }

    system("pause");
    return 0;
}

Podemos ter uma visão diferente, talvez mais intuitiva para você, através do seguinte diagrama de blocos:

Flexibilidade e Comparação com o while6.5.1

O comando for respeita as mesmas normas de sintaxe que o if e o while: a condição pode envolver qualquer expressão lógica ou matemática, e o uso de chaves { } é indispensável para agrupar múltiplos comandos. Para facilitar a compreensão, veja como uma mesma tarefa (somar números de 1 a 10) pode ser escrita em ambas as estruturas:

// Versão com FOR
for(i = 1; i <= 10; i++){
    s = s + i;
}

// Versão com WHILE
i = 1;
while (i <= 10){
    s = s + i;
    i++;
}

Omitindo Cláusulas no for6.5.2

Você pode omitir qualquer uma das três cláusulas do for (inicialização, condição ou incremento), dependendo da lógica do seu programa. Entretanto, é obrigatório manter os dois operadores de ponto e vírgula (;), que servem como delimitadores para o compilador.

• Sem Inicialização: Útil quando a variável de controle já foi definida anteriormente no código.

  for (; a <= b; a++) { ... }
  

• Sem Condição: Cria um laço infinito, pois a ausência de teste é interpretada como uma condição sempre verdadeira.

  for (c = a; ; c++) { ... }
  

• Sem Incremento: Frequentemente utilizado quando a atualização da variável ocorre de forma personalizada dentro do bloco de comandos.

  for (c = a; c <= b; ) {
      printf("%d \n", c);
      c++; // Incremento manual
  }
  

Operador de Vírgula e Tipos de Dados6.5.3

O operador vírgula (,) funciona como um separador, permitindo que você execute múltiplas instruções sequencialmente dentro das cláusulas do for. Isso possibilita, por exemplo, controlar duas variáveis simultaneamente no mesmo laço:

for (i = 0, j = 100; i < j; i++, j--) {
    printf("i = %d e j = %d \n", i, j);
}

Além disso, a variável de controle não precisa ser apenas do tipo int. Você pode utilizar uma variável do tipo char para percorrer, por exemplo, o alfabeto de 'A' até 'Z'.

Comando do-while6.6

O comando do-while é uma estrutura de repetição bastante similar ao while, porém com uma diferença fundamental na ordem de processamento: enquanto o while avalia a condição antes de executar os comandos, o do-while executa o bloco de instruções primeiro para somente depois testar a condição.

A forma geral do comando é:

do {
    sequência de comandos;
} while (condição);

Ao utilizar o do-while, você garante que o programa siga esta ordem de execução:

• Execução Inicial: A sequência de comandos dentro das chaves é processada imediatamente.
• Avaliação da Condição: Após a execução do bloco, o programa testa a expressão lógica.
  • Se for verdadeira (valor diferente de zero), o fluxo retorna ao comando do, repetindo o bloco.
  • Se for falsa (zero), o laço é encerrado.

Diferença Prática entre while e do-while6.6.1

A escolha entre essas duas estruturas depende de quantas vezes você precisa que o código seja executado no mínimo:

• while: Como a condição é testada no início, se ela for falsa logo de cara, o bloco de comandos nunca será executado (zero ou mais repetições).
• do-while: Como a execução ocorre antes do teste, o bloco de comandos será processado pelo menos uma vez, independentemente da condição (uma ou mais repetições).

O exemplo abaixo ilustra o uso do do-while para criar um menu de opções. O programa exibe as alternativas e captura a sua entrada, repetindo o processo enquanto você digitar um valor inválido:

#include <stdio.h>
#include <stdlib.h>

int main(){
    int i;
    do {
        printf ("Escolha uma opcao:\n");
        printf ("(1) Opção 1\n");
        printf ("(2) Opção 2\n");
        printf ("(3) Opção 3\n");
        scanf("%d", &i);
    } while ((i < 1) || (i > 3));

    printf ("Voce escolheu a Opcao %d.\n", i);
    system("pause");
    return 0;
}

Regras de Sintaxe Importantes6.6.2

O comando do-while segue as mesmas recomendações de uso de chaves e definições lógicas dos comandos anteriores. No entanto, ele possui uma particularidade sintática exclusiva:

do {
    printf("Valor %d\n", i);
    i++;
} while(i < 10); // Este ponto e vírgula é obrigatório!

Essa exigência ocorre porque a condição é o último elemento da estrutura. O ponto e vírgula sinaliza ao compilador que a definição daquele laço específico foi finalizada. Assim como nas outras estruturas de repetição, lembre-se que é sua responsabilidade garantir que a variável de controle seja alterada dentro do bloco para evitar um laço infinito.

Aninhamento de Repetições6.7

Uma repetição aninhada ocorre quando você utiliza um comando de repetição dentro do bloco de comandos de outro comando de repetição. Essa estrutura é conceitualmente idêntica ao aninhamento que você já praticou com o comando if, permitindo criar ciclos de execução dentro de outros ciclos.

A forma geral de uma repetição aninhada é:

repetição (condição 1) {
    sequência de comandos;
    repetição (condição 2) {
        sequência de comandos;
        repetição...
    }
}

Neste contexto, o termo "repetição" pode representar qualquer um dos três comandos da linguagem C: while, for ou do-while.

Durante a execução, o programa avalia primeiramente a condição 1. Se o resultado for verdadeiro (diferente de zero), ele inicia o processamento do seu bloco interno, o que inclui a avaliação da condição 2. É fundamental notar que os comandos da segunda repetição só serão processados se a condição da primeira for satisfeita. Esse comportamento se replica em cascata para cada novo nível de aninhamento que você encontrar.

Aplicação Prática6.7.1

O aninhamento de repetições é extremamente útil quando você precisa percorrer dois ou mais conjuntos de valores relacionados. Um exemplo clássico é a impressão de uma matriz identidade de tamanho $4 \times 4$. Para realizar essa tarefa, você precisa percorrer as quatro linhas da matriz e, para cada uma dessas linhas, percorrer as suas quatro colunas correspondentes. Um único comando de repetição não seria suficiente para gerenciar essas duas dimensões simultaneamente.

Abaixo, você pode comparar como essa lógica é implementada utilizando diferentes estruturas:

// Versão com FOR
#include <stdio.h>
#include <stdlib.h>

int main(){
    int i, j;
    for (i = 1; i < 5; i++){
        for (j = 1; j < 5; j++){
            if(i == j)
                printf("1 ");
            else
                printf("0 ");
        }
        printf("\n");
    }
    system("pause");
    return 0;
}

// Versão com WHILE
#include <stdio.h>
#include <stdlib.h>

int main(){
    int i = 1, j;
    while(i < 5){
        j = 1;
        while(j < 5){
            if(i == j)
                printf("1 ");
            else
                printf("0 ");
            j++;
        }
        printf("\n");
        i++;
    }
    system("pause");
    return 0;
}

Comando continue6.8

O comando continue é outro recurso de controle de fluxo utilizado exclusivamente dentro de estruturas de repetição como for, while e do-while. Enquanto o comando break interrompe e encerra o laço definitivamente, o continue interrompe apenas a iteração atual, saltando imediatamente para o próximo ciclo de execução da repetição.

Quando o programa encontra um continue, todos os comandos que estiverem abaixo dele, dentro do corpo do laço, são ignorados naquela volta específica. Em um laço for, o fluxo salta para a etapa de incremento; em laços while ou do-while, o programa retorna direto para o teste da condição.

O exemplo a seguir demonstra o uso do continue para imprimir apenas números ímpares entre a e b:

#include <stdio.h>
#include <stdlib.h>

int main(){
    int a, b;
    printf("Digite o valor de a: ");
    scanf("%d", &a);
    printf("Digite o valor de b: ");
    scanf("%d", &b);

    while (a <= b){
        a = a + 1;
        if(a % 2 == 0)
            continue; // Pula a impressão se o número for par
        printf("%d \n", a);
    }

    system("pause");
    return 0;
}

Abaixo, você pode visualizar a lógica de execução deste comando através do fluxograma:

Comando continue6.9

O comando continue guarda semelhanças com o comando break, pois ambos ignoram o restante das instruções dentro de um laço. Entretanto, a diferença funcional é determinante: enquanto o break encerra o comando de repetição definitivamente, o continue interrompe apenas a iteração atual e salta para a próxima repetição do laço, caso ela exista.

Devido a essa característica, o continue é de uso exclusivo dentro de laços de repetição, ao contrário do break, que também pode ser aplicado no comando switch. Quando executado, o programa ignora os comandos restantes daquela volta específica e retorna imediatamente para testar a condição do laço (no caso do while e do-while) ou para a cláusula de incremento (no caso do for).

O exemplo abaixo ilustra um programa que imprime valores entre a e b, mas pula especificamente a impressão do número 5:

#include <stdio.h>
#include <stdlib.h>

int main(){
    int a, b;
    printf("Digite o valor de a: ");
    scanf("%d", &a);
    printf("Digite o valor de b: ");
    scanf("%d", &b);

    while (a <= b){
        a = a + 1;
        if(a == 5)
            continue; // Interrompe a iteração atual e volta ao teste do while
        printf("%d \n", a);
    }

    system("pause");
    return 0;
}

Regras de Uso e Riscos de Lógica6.9.1

Para utilizar o continue de forma didática e segura, você deve seguir estas orientações:

• Uso com Condicionais: O comando deve estar sempre abrigado por um if ou else dentro da repetição. Isso garante que apenas iterações específicas, que atingirem um determinado resultado, sejam ignoradas.
• Risco de Laço Infinito: Se você posicionar o continue fora de uma estrutura condicional, o programa ignorará sistematicamente todas as execuções do laço. Além disso, em estruturas como o while, se o incremento da variável de controle estiver posicionado após o continue, você criará um laço infinito, pois o programa nunca chegará à linha que atualiza o valor da condição de parada.

Abaixo, veja a representação visual do fluxo de execução do comando:

Questões6.10

1. Escreva um programa em C que utilize um laço for para imprimir todos os números inteiros de 1 a 20 na tela.

• Entrada: Nenhuma.
• Saída Esperada: 1 2 3 ... 20 (um por linha ou separados por espaço).

2. Crie um programa que utilize o laço while para exibir uma contagem regressiva de 10 até 0. Ao final, imprima a mensagem "FIM!".

• Entrada: Nenhuma.
• Saída Esperada: 10, 9, 8, ... 0, FIM!

3. Peça ao usuário para digitar um número inteiro. Utilize um laço (pode ser for ou while) para imprimir a tabuada desse número de 1 a 10.

• Entrada: Um número (ex: 5).
• Saída Esperada:
  • 5 x 1 = 5
  • 5 x 2 = 10
  • ...
  • 5 x 10 = 50

4. Escreva um programa que leia 5 números inteiros fornecidos pelo usuário. Utilize um laço para ler esses números e, a cada leitura, some-o a uma variável acumuladora. Ao final, imprima a soma total e a média dos valores.

• Entrada: 5 números inteiros (ex: 10, 20, 10, 20, 40).
• Saída Esperada: Soma: 100, Média: 20.0.

5. Utilize a estrutura do-while para criar um programa que peça ao usuário para digitar uma nota entre 0.0 e 10.0. Se o usuário digitar um valor inválido (fora desse intervalo), o programa deve exibir "Nota inválida" e pedir o valor novamente. O programa só deve parar quando uma nota válida for inserida.

• Entrada: Repetidas tentativas de números (ex: -1, 15, 7).
• Saída: Apenas quando digitar 7: "Nota valida: 7.0".

6. Crie um programa que receba dois números inteiros, A e B (considere que A < B). Utilize um laço for para percorrer o intervalo de A até B e imprimir apenas os números pares.

• Dica: Use o operador % (resto) para verificar se é par.
• Entrada: Dois inteiros (ex: 2 e 10).
• Saída Esperada: 2 4 6 8 10.

7. Escreva um programa que calcule o fatorial de um número inteiro não negativo fornecido pelo usuário. Lembre-se que o fatorial de N ($N!$) é a multiplicação:

$$N \times (N-1) \times (N-2) \times ... \times 1$$

Exemplo: $5! = 5 \times 4 \times 3 \times 2 \times 1 = 120$).

• Entrada: Um número inteiro positivo (ex: 5).
• Saída Esperada: Fatorial: 120.

8. Utilize laços aninhados (um laço dentro de outro) para desenhar um quadrado de asteriscos na tela. O usuário deve informar o tamanho do lado do quadrado.

• Entrada: Um inteiro N (ex: 4).
• Saída Esperada:

****
****
****
****

9. Escreva um programa que leia um número inteiro N e imprima as N primeiras linhas do Triângulo de Floyd. O triângulo é formado por números sequenciais dispostos em linhas crescentes.

• Entrada: Um inteiro (ex: 4).
• Saída Esperada:

1
2 3
4 5 6
7 8 9 10

10. Crie um programa que peça um número inteiro positivo maior que 1 ao usuário e determine se ele é um número PRIMO (divisível apenas por 1 e por ele mesmo). Para isso, você precisará usar um laço para testar a divisibilidade do número por todos os antecessores até chegar na metade do valor dele.

• Entrada: Um número inteiro (ex: 7).
• Saída Esperada: "Eh primo".
• Entrada Alternativa: 9.
• Saída Esperada: "Nao eh primo".

11. A sequência de Fibonacci começa com 0 e 1, e os próximos números são sempre a soma dos dois anteriores (0, 1, 1, 2, 3, 5, 8, 13...). Escreva um programa que leia um inteiro N e imprima os N primeiros termos dessa sequência.

• Entrada: Um inteiro N (ex: 6).
• Saída Esperada: 0 1 1 2 3 5.

Próximos passos6.11

No próximo capítulo, Arrays (Vetores e Matrizes), aprenderemos a armazenar múltiplos valores de um mesmo tipo em uma única variável composta. Veremos como declarar vetores (arrays) além de como acessar seus elementos através de índices.