Praticando C#: laços de repetição

While e do while - Apresentação

Boas-vindas! Meu nome é Iasmin Araújo, sou instrutora na Escola de Programação da Alura, e irei te acompanhar ao longo dessa jornada de aprendizagem.

Audiodescrição: Iasmin se descreve como uma mulher branca, com cabelo castanho-escuro longo e liso repartido ao meio, sobrancelhas castanho-escuras, e olhos verdes. Ela veste uma blusa bege, e está sentada em uma cadeira preta com detalhes em rosa-claro, em frente a um microfone cinza, com uma parede clara ao fundo iluminada em gradiente azul.

O que vamos aprender?

Neste curso, vamos praticar os laços de repetição. Para isso, abordaremos diversos tópicos:

• Como funcionam os laços de repetição;
• Quais são os laços de repetição em C#;
• Aprenderemos a usar while, do while, for e foreach;
• Entenderemos o que leva à ocorrência de loops infinitos;
• Conheceremos as palavras-chave break e continue.

Conclusão

Essa diversidade de tópicos nos permitirá praticar e aprofundar bastante nossos conhecimentos. No próximo vídeo, daremos início à prática. Esperamos você na sequência!

While e do while - While

Neste vídeo, trabalharemos com o laço de repetição while.

Utilizando o laço de repetição while

Para começar, vamos considerar a seguinte tarefa: queremos criar um contador regressivo que imprima os números de 5 até 1, em ordem decrescente, e, ao final, informe que a contagem chegou ao fim. No Visual Studio, já temos uma solução para esse problema, que consiste em imprimir cada número individualmente. Abaixo, temos o código inicial usado para isso:

Program.cs:

Console.WriteLine(5);
Console.WriteLine(4);
Console.WriteLine(3);
Console.WriteLine(2);
Console.WriteLine(1);

Console.WriteLine("A contagem chegou ao fim!");

Vamos executar para conferir se a solução funciona? O resultado esperado aparece no terminal normalmente, com os números em ordem decrescente e a mensagem.

Retorno no terminal:

5
4
3
2
1
A contagem chegou ao fim!

Incrementando o contador regressivo

Agora, imagine que queremos incrementar essa solução. Dessa forma, em vez de um contador regressivo de 5 até 1, queremos que vá de 10 até 1. Para isso, seguindo o padrão atual, podemos duplicar várias vezes o Console.WriteLine() e atualizar os valores. Teremos um Console.WriteLine() para 10, 9, 8, 7 e 6. Na sequência, continuamos como estava anteriormente.

Console.WriteLine(10);
Console.WriteLine(9);
Console.WriteLine(8);
Console.WriteLine(7);
Console.WriteLine(6);
Console.WriteLine(5);
Console.WriteLine(4);
Console.WriteLine(3);
Console.WriteLine(2);
Console.WriteLine(1);

Console.WriteLine("A contagem chegou ao fim!");

Ao executar a aplicação, ela funcionará conforme esperado.

Entretanto, se quisermos evoluir ainda mais a contagem regressiva, com valores de 30 até 1, será que a melhor forma seria imprimir mais 20 vezes com Console.WriteLine()?

O que são laços de repetição?

Escrever repetidamente não parece ser a melhor abordagem. Para isso, as linguagens de programação oferecem uma estrutura específica: os laços de repetição.

Vamos analisar como os laços de repetição funcionam? Um laço permite executar comandos se uma condição for verdadeira. Com base nisso, há 3 tipos de laços:

• while;
• do while;
• E for.

Todos são disponibilizados pelo C# para realizar repetições.

Entendendo a sintaxe do laço while

O laço de repetição while possui a seguinte sintaxe:

while (condição)
{
    bloco de código
}

Inicialmente, temos a palavra-chave while, que significa "enquanto" em inglês, seguida de parênteses contendo uma condição. Enquanto essa condição for verdadeira, executaremos repetidamente um bloco de código específico, escrito entre chaves.

Operadores de comparação e operadores lógicos

Para definir essas condições, utilizamos operadores de comparação, apresentados no curso da Alura sobre condicionais, e operadores lógicos, como AND, OR e NOT.

Esses operadores são usados para verificar condições.

Operadores de comparação:

Construindo um laço while

Vamos entender na prática como utilizar o while? Comentaremos o código anterior e adaptaremos para obter o mesmo resultado, mas usando o laço while.

Continuaremos com um contador regressivo de 10 até 1. Para isso, precisamos de uma condição: o número a ser impresso deve ser maior ou igual a 1.

A contagem regressiva começa em 10, então podemos criar uma variável chamada contador, que será um int, e essa variável receberá o valor inicial de 10.

/*Console.WriteLine(10);
Console.WriteLine(9);
Console.WriteLine(8);
Console.WriteLine(7);
Console.WriteLine(6);
Console.WriteLine(5);
Console.WriteLine(4);
Console.WriteLine(3);
Console.WriteLine(2);
Console.WriteLine(1);

Console.WriteLine("A contagem chegou ao fim!");*/

int contador = 10;

Feito isso, podemos pensar no laço. Começaremos declarando while; depois, vamos abrir e fechar parênteses, onde passaremos a condição de que a variável contador seja maior ou igual a 1 (>= 1).

No escopo do while, adicionaremos o que deve se repetir. Queremos que o número do contador seja impresso, então utilizamos Console.WriteLine(contador).

A variável contador precisa ser atualizada, ou seja, a ideia é que ela comece com 10, mas diminua com o tempo. Para isso, decrementamos com contador--.

No final da contagem regressiva, após repetir várias vezes a impressão dos números, queremos simplesmente indicar que a contagem acabou. Para isso, usaremos um Console.WriteLine() com a mensagem "A contagem chegou ao fim!".

// código omitido

int contador = 10;
while (contador >= 1)
{
    Console.WriteLine(contador);
    contador--;
}
Console.WriteLine("A contagem chegou ao fim!");

Verificando o resultado

Vamos executar o programa para verificar o resultado? Assim, podemos explorar melhor como o loop funciona. Ao executar, temos uma contagem de 10 até 1 e a contagem chega ao fim.

Com tudo correto no comportamento do programa, podemos explorar mais a fundo como isso funciona. Primeiro, criamos a variável contador com o valor 10. Como o C# lê essas instruções?

Temos um while, que significa "enquanto", e a condição que precisa ser verificada. A partir disso, ele observa a variável contador no momento atual.

Ao começar, o valor é 10, então verificamos: 10, valor do contador, é maior ou igual a 1? Se sim, imprimimos o contador atual, que é 10. Após imprimir 10, podemos atualizar o contador, que fará um decremento e passará a valer 9.

Quando chegamos ao fechamento das chaves, voltamos para o laço while. Por isso, dizemos que é um laço, pois fazemos voltas, como se andássemos em círculos.

Nesse momento, verificamos se o contador atual, agora igual a 9, é maior ou igual a 1. Se sim, imprimimos e atualizamos novamente; com isso, passa a valer 8.

Depois voltamos e permanecemos nesse loop até chegarmos ao número 1. Quando chegamos ao número 1, ele verifica: o contador, que vale 1, é maior ou igual a 1? Sim, então imprimimos, fazemos o decremento, e o contador passa a valer 0.

Agora, ao final do laço, o contador valerá 0, que não é maior ou igual a 1, por isso, não entramos no loop do while novamente. Na próxima linha, indicamos que a contagem chegou ao fim. Esse é o comportamento de um loop, ou seja, de um laço: ele percorre círculos até chegar ao final.

While e do while - Do while

Além do laço while, temos algumas outras estruturas, como o do while.

Utilizando o laço de repetição do while

Entendendo a sintaxe do laço do while

O laço do while é semelhante ao while, mas com uma diferença crucial: ele garante que o bloco de código seja executado pelo menos uma vez antes de verificar a condição, pois a condição é testada após a execução do bloco.

Observe abaixo a sintaxe do laço de repetição do while:

do
{
    bloco de código
}
while (condicao);

No laço de repetição do while, utilizamos inicialmente a palavra-chave do e abrimos chaves logo abaixo, onde vamos inserir um bloco de código que será executado. Depois, fazemos a verificação da condição no bloco while.

A diferença entre o while e o do while é que, no do while, executamos a instrução pelo menos uma vez. Já no while, pode ser que a instrução nunca seja executada, pois a condição é testada antes da execução.

Construindo um laço do while

Se quisermos adaptar o while para do while, podemos copiar o que fizemos anteriormente, comentar o laço while, e colar o trecho abaixo para realizar os ajustes necessários. Em seguida, basta recortar o while com a condição para o final do bloco, e adicionar a palavra-chave do antes da abertura de chaves.

Program.cs:

// código omitido

int contador = 10;
do
{
    Console.WriteLine(contador);
    contador--;
}
while (contador >= 1);
Console.WriteLine("A contagem chegou ao fim!");

A diferença é que o do executa o bloco antes de fazer o teste. Ao executar, teremos o mesmo resultado tanto para o while quanto para o do while.

No entanto, se contador for igual a 0, o do executa. Ele imprime o 0 no retorno e depois diz que a contagem chegou ao fim, pois a tradução de do é "execute", ou seja, faça algo antes de testar. Ele imprime o contador antes de testar se é maior ou igual a 1, enquanto no while isso não acontece.

Utilizando o laço do while em menus

Uma utilidade interessante ao trabalhar com loops é quando queremos mostrar um menu para a pessoa usuária até que ela escolha sair.

No curso em que abordamos switch case, havia um menu com três opções:

• Visualizar produtos (Opção 1);
• Fazer pedido (Opção 2);
• Sair (Opção 0).

// código omitido

Console.WriteLine("\nMENU:");
Console.WriteLine("1 - Ver produtos");
Console.WriteLine("2 - Fazer pedido");
Console.WriteLine("0 - Sair");
Console.Write("Escolha uma opção: ");

int opcao = int.Parse(Console.ReadLine());

switch(opcao)
{
    case 1:
        Console.WriteLine("Mostrando produtos…");
        break;
    case 2:
        Console.WriteLine("Pedido realizado!");
        break;
    case 0:
        Console.WriteLine("Saindo…");
        break;
    default:
        Console.WriteLine("Opção inválida!");
        break;
}

A pessoa usuária escolheria uma opção com base no que desejava. Se fosse 1, os produtos seriam exibidos; se fosse 2, o pedido seria feito; e assim por diante.

Podemos criar um laço de repetição do while para manter o menu ativo até que a pessoa usuária digite 0 para sair. Vamos entender como isso é feito?

Para começar, vamos declarar um bloco do e mover as instruções para seu escopo. Feito isso, adicionaremos a condição no while após as chaves. Nesse caso, a condição é que a pessoa usuária precisa digitar 0 para sair do menu. Portanto, enquanto a variável opcao for diferente (!=) de 0, continuamos no loop.

Importante! A variável opcao deve ser declarada fora do loop para que possa ser atualizada conforme a pessoa usuária digitar sua escolha.

// código omitido

int opcao;
do
{
    Console.WriteLine("\nMENU:");
    Console.WriteLine("1 - Ver produtos");
    Console.WriteLine("2 - Fazer pedido");
    Console.WriteLine("0 - Sair");
    Console.Write("Escolha uma opção: ");

    opcao = int.Parse(Console.ReadLine());

    switch(opcao)
    {
        case 1:
            Console.WriteLine("Mostrando produtos…");
            break;
        case 2:
            Console.WriteLine("Pedido realizado!");
            break;
        case 0:
            Console.WriteLine("Saindo…");
            break;
        default:
            Console.WriteLine("Opção inválida!");
            break;
    }
} 
while (opcao != 0);

Observação: para tornar a execução mais organizada, podemos limpar a tela após cada escolha da pessoa usuária utilizando o método Console.Clear(). No entanto, optamos por não limpar a tela para manter as opções anteriores visíveis.

Verificando o resultado

Ao executar a aplicação, temos o menu com as três opções. Quando escolhemos a opção 1, por exemplo, os pedidos são exibidos e o menu surge novamente. Da mesma forma, quando escolhemos a opção 2, é exibido na tela e temos de novo o menu.

Resolvendo o problema de loop infinito

Por fim, lembre-se que, para um loop funcionar corretamente, precisamos de três elementos: *inicialização; condição; e atualização de uma variável.

Sem atualizar a variável, enfrentamos o problema do loop infinito. Por exemplo: se esquecermos de decrementar o contador, o loop nunca terminará.

Vamos ao Visual Studio para ilustrar melhor?

Sobre o problema do loop infinito, se voltarmos ao while, precisamos da inicialização, como definir o contador igual a 0; da condição, como o contador ser maior ou igual a 1; e da atualização, como contador--.

Sem atualização, teremos um loop infinito.

// código omitido

int contador = 0;
while (contador >= 1)
{
    Console.WriteLine(contador);
    contador--;
}
Console.WriteLine("A contagem chegou ao fim!");

// código omitido

Executar esse código sem a linha de atualização resultará em um loop infinito, pois o contador nunca será decrementado, mantendo a condição sempre verdadeira.

Conclusão

Com isso, conseguimos entender operadores, loops e laços de repetição em C#. Na sequência, discutiremos outros loops da linguagem C#!

Sobre o curso Praticando C#: laços de repetição

O curso Praticando C#: laços de repetição possui 40 minutos de vídeos, em um total de 21 atividades. Gostou? Conheça nossos outros cursos de em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• While e do while
• For e foreach