Estruturas de Repetição em C#.

Este capítulo explora o uso de estruturas de repetição (while, do/while e for) para automatizar tarefas repetitivas. Essas estruturas permitem executar blocos de código múltiplas vezes, otimizando a escrita e adaptando-se a cenários com iterações previsíveis ou dinâmicas.

1. Laços de Repetição: While e Do/While

O while executa um bloco de código enquanto uma condição for verdadeira. Já o do/while garante que o bloco seja executado pelo menos uma vez, mesmo que a condição seja falsa inicialmente.

Fluxograma do While

Legenda: O fluxograma ilustra como a condição é verificada no início de cada iteração. Se verdadeira, o bloco é executado; se falsa, o loop termina.

1.1 Exemplo Detalhado do While

1  int contador = 1; // Inicialização da variável
2  while (contador <= 10) { // Condição de parada
3      Console.WriteLine("Contador: " + contador);
4      contador++; // Incremento para evitar loop infinito
5  }
6  Console.WriteLine("Fim do loop");

Explicação do Fluxo:

• Linha 1: A variável contador é declarada e inicializada com 1.
• Linha 2: A condição contador <= 10 é verificada. Se verdadeira, o bloco entre chaves é executado.
• Linha 4: O incremento contador++ é crucial para garantir que a condição eventualmente se torne falsa.
• Linha 6: Executada após o loop terminar, indicando o fim do processo.

1.2 Aplicação Prática em Menus

1  int opcao;
2  do {
3      Console.WriteLine("1 - Cadastrar | 2 - Listar | 3 - Sair");
4      opcao = int.Parse(Console.ReadLine()); // Leitura da entrada do usuário
5  } while (opcao != 3); // Repete até a opção 3 ser selecionada

Funcionamento: O menu é exibido repetidamente até que o usuário escolha a opção 3. O do/while é ideal aqui, pois o menu deve aparecer pelo menos uma vez.

2. Laço For: Controle de Iterações Previsíveis

O for é utilizado quando o número de iterações é conhecido. Sua sintaxe combina inicialização, condição e incremento em uma única linha.

1  for (int i = 1; i <= 5; i++) { // Inicialização; Condição; Incremento
2      Console.WriteLine("Iteração " + i);
3  }

Passo a Passo:

• Inicialização (int i = 1): Executada uma única vez, antes do loop iniciar.
• Condição (i <= 5): Verificada antes de cada iteração. Se falsa, o loop é interrompido.
• Incremento (i++): Executado após cada iteração, atualizando a variável de controle.

Vantagem: Centraliza o controle do loop, tornando o código mais legível e menos propenso a erros.

3. Exemplo Completo: Jogo de Adivinhação

Implementação de um jogo com 5 tentativas para adivinhar um número entre 0 e 10, demonstrando o uso combinado de loops e estruturas condicionais.

1  Random rand = new Random();
2  int numeroSorteado = rand.Next(0, 11); // Gera número entre 0 e 10
3  int tentativas = 5;
4  
5  while (tentativas > 0) {
6      Console.Write("Digite seu palpite: ");
7      int palpite = int.Parse(Console.ReadLine());
8      
9      if (palpite == numeroSorteado) {
10         Console.WriteLine("Parabéns! Você acertou!");
11         break; // Interrompe o loop imediatamente
12     } else {
13         tentativas--; // Decrementa tentativas restantes
14         Console.WriteLine($"Errou! Tentativas restantes: {tentativas}");
15     }
16 }
17 Console.WriteLine("O número sorteado era: " + numeroSorteado);

Quadro 1 - Jogo de Adivinhação (Número Sorteado = 7)

Explicação do Quadro 1: O usuário errou nas quatro primeiras tentativas, reduzindo as tentativas restantes. Na quinta e última tentativa, o palpite correto (7) aciona o break, interrompendo o loop. Mesmo com tentativas = 0, o acerto na última chance é registrado antes do término do loop.

4. Comparação Entre While e For

Quando usar cada estrutura:

• For:
  • Iterações com número definido (ex: percorrer arrays).
  • Controle explícito da variável de iteração.
  • Exemplo: for (int i = 0; i < 10; i++).
• While:
  • Condições complexas ou dependentes de entrada externa (ex: menus, validações).
  • Número de iterações desconhecido.
  • Exemplo: while (senha != "1234").

5. Boas Práticas e Armadilhas Comuns

• Evite loops infinitos: Sempre atualize a variável de controle dentro do bloco.
• Cuidado com off-by-one errors: Verifique se a condição inclui/exclui o valor correto (ex: <= vs <).
• Prefira for para contagens: Melhora a legibilidade e reduz erros.
• Use break e continue com moderação: Podem tornar o fluxo do código difícil de seguir.

Veja o seguinte vídeo e acompanhe no seu computador para melhor entendimento: link

6. Considerações Finais

Este capítulo demonstrou a importância das estruturas de repetição para controlar o fluxo de execução em programas C#. Através dos laços while, do/while e for, é possível automatizar tarefas repetitivas de forma eficiente, reduzindo a redundância de código e adaptando-se a cenários dinâmicos.

A integração entre estruturas condicionais e de repetição, como visto no jogo de adivinhação, permite criar lógicas complexas e interativas. O uso correto de break para interromper loops antecipadamente e o controle preciso de variáveis de iteração são fundamentais para evitar erros comuns, como loops infinitos.

A prática desses conceitos é essencial para dominar o equilíbrio entre flexibilidade e controle. Experimente modificar os exemplos apresentados:

• Substituir while por for no jogo de adivinhação;
• Criar um menu com múltiplas camadas usando loops aninhados;
• Implementar validação de entrada de dados para evitar erros de conversão.

Os fluxogramas auxiliam na visualização do fluxo de controle, especialmente em loops com condições interdependentes. Utilize essas representações gráficas para planejar algoritmos antes da implementação.

Por fim, lembre-se de que o domínio de estruturas de repetição é um dos pilares para a construção de programas robustos e eficientes, sendo aplicável desde soluções simples até sistemas críticos de alta complexidade.