Comando while: estrutura de repetição

Aqui se inicia um dos assuntos mais fantásticos da programação de computadores: as estruturas de repetição. Recomendamos que você já tenha lido o artigo anterior, sobre estruturas condicionais.

Mas vamos ao que interessa!

O que são estruturas de repetição?

Também conhecida como loop ou laço, uma estrutura de repetição é uma construção que as linguagens de programação fornecem para que o programador possa economizar trabalho com códigos repetitivos.

Imagine que precisamos escrever um algoritmo para imprimir na tela a mensagem “Algol.dev” 10 vezes. O código abaixo faz exatamente isso:

1.println("Algol.dev");
2.println("Algol.dev");
3.println("Algol.dev");
4.println("Algol.dev");
5.println("Algol.dev");
6.println("Algol.dev");
7.println("Algol.dev");
8.println("Algol.dev");
9.println("Algol.dev");
10.println("Algol.dev");

O problema desse tipo de código está na sua escalabilidade (capacidade de crescimento). Imagine que, ao invés de 10, precisássemos imprimir a mensagem 1000 vezes. O código seria impraticável de se escrever!

Pois bem! Para resolver esse tipo de problema surgiram as estruturas de repetição. Veja no código abaixo como a mensagem poderia ser escrita 1000 vezes utilizando uma estrutura de repetição genérica (apenas ilustrativa):

1.estrutura(repete 1000){
2.    println("Algol.dev");
3.}

A estrutura de repetição é um escopo que fornece um controle para repetição de um comando ou um conjunto de comandos. Na linha 2 (código acima) a mensagem “Algol.dev” é automaticamente repetida 1000 vezes, pois está dentro de um escopo de uma estrutura de repetição.

O comando while

Na maioria das linguagens de programação, as estruturas de repetição básicas são implementadas por meio do comando while, cuja tradução literal é “enquanto”.

O código abaixo ilustra a estrutura do comando while:

1.while(expressão condicional){
2.    // comandos a serem repetidos
3.}

Funciona da seguinte forma: a expressão condicional (linha 1 do código acima) é testada e, “enquando” retornar verdadeiro (true), os comandos (linha 2 do código acima) são repetidos. No momento em que a expressão condicional retornar um valor falso (false), os comandos deixam de ser repetidos.

Veja no código abaixo um exemplo da impressão dos números de 1 a 10, utilizando o comando while:

1.int count=1;
2.while(count <= 10){
3.    println(count);
4.    count++;
5.}

Observe que a variável “count” é uma variável de controle que é usada pelo comando while para controlar as repetições.

O comando “count++” (linha 4 do código acima) incrementa o valor da variável de controle a cada nova repetição. Quando o valor de “count” alcança o valor 11, a expressão “count <= 10” (linha 2 do código acima) retorna falso e as repetições são interrompidas.

Veja abaixo a simulação da execução do algoritmo acima.

Veja abaixo esse código completo em várias linguagens de programação diferentes:

1.import java.util.Scanner;
2.class Main {
3.    public static void main(String[] args) {
4.        int count=1;
5.        while(count <= 10){
6.            System.out.println(count);
7.            count++;
8.        }
9.    }
10.}

1.#include <stdio.h>
2.int main(void) {
3.    int count=1;
4.    while(count <= 10){
5.        printf("%d\n",count);
6.        count++;
7.    }
8.}

1.#include <iostream>
2.int main() {
3.    int count=1;
4.    while(count <= 10){
5.        std::cout << count << std::endl;
6.        count++;
7.    }
8.}

1.using System;
2.class MainClass {
3.    public static void Main (string[] args) {
4.        int count=1;
5.        while(count <= 10){
6.            Console.WriteLine(count);
7.            count++;
8.        }
9.    }
10.}

1.count=1
2.while count <= 10:
3.    print(count)
4.    count=count+1

Reconhecimento de intervalos do comando while

A maior habilidade que um programador deve ter no que diz respeito às repetições é a capacidade de identificar rapidamente os seus intervalos de valores.

Para exemplificar, vamos retomar o código da seção anterior:

1.int count=1;
2.while(count <= 10){
3.    println(count);
4.    count++;
5.}

É fácil observar que o valor da variável de controle “count” começa em 1. Também é fácil observar pela expressão “count <= 10” que as repetições terminam quando o valor de “count” ultrapassa o valor 10. E pela expressão “count++”, observamos que a variável “count” é incrementada de 1 em 1 unidade.

Portanto, podemos concluir que esta estrutura de repetição impõe um intervalo de 10 repetições (de 1 a 10 com 1 passo de incremento). A ilustração abaixo detalha o reconhecimento de intervalo do algoritmo acima:

Um segundo exemplo do comando while

Vamos a um exemplo diferente:

1.int count=3;
2.while(count <= 11){
3.    println(count);
4.    count=count+2;
5.}

É fácil observar que o valor da variável de controle “count” começa em 3. Também é fácil observar pela expressão “count <= 11” que as repetições terminam quando o valor de “count” ultrapassa o valor 11. E pela expressão “count=count+2”, observamos que a variável “count” é incrementada de 2 em 2 unidades.

Portanto, podemos concluir que esta estrutura de repetição impõe um intervalo de 5 repetições (de 3 a 11 com 2 passos de incremento). A ilustração abaixo detalha o reconhecimento de intervalo do algoritmo acima:

Um exemplo mais difícil

Esse exemplo é mais desafiador. A variável de controle decrementa ao invés de incrementar:

1.int count=30;
2.while(count > 2){
3.    println(count);
4.    count=count-7;
5.}

Podemos observar que o valor da variável de controle “count” começa em 30. Também é fácil observar pela expressão “count > 2” que as repetições terminam quando o valor de “count” alcança 2 ou um valor menor. E pela expressão “count=count-7”, observamos que a variável “count” é decrementada de 7 em 7 unidades.

Portanto, podemos concluir que esta estrutura de repetição impõe um intervalo de 4 repetições (de 30 a 9 com 7 passos de decremento). A ilustração abaixo detalha o reconhecimento de intervalo do algoritmo acima:

Continue a sua evolução nesse assunto e leia o nosso artigo sobre o comando “for”, a estrutura de repetição mais utilizada pelos programadores profissionais.