C++ while

Até agora, cada linha dos seus programas rodou uma vez só, de cima para baixo. Mas boa parte do trabalho de um computador é repetir: mostrar os 30 alunos da turma, somar os preços de todos os produtos, perguntar de novo até a pessoa digitar algo válido. Para isso existem os laços (em inglês, loops). O mais simples deles é o while, que quer dizer "enquanto": enquanto a condição for verdadeira, repita.

Todos os programas desta aula foram compilados com o g++ 15 na máquina fictícia da Ana (usuária ana, computador notebook), na pasta ~/cpp, com o comando padrão do guia: g++ -std=c++23 -Wall -Wextra arquivo.cpp -o programa (veja Compilar com g++). Você pode rodar cada um no editor do guia.

A ideia: "enquanto tiver louça, lave um prato"

Imagine que alguém deixou um bilhete para você: "Enquanto tiver louça na pia, lave um prato." Você não sabe quantos pratos há. Mesmo assim, a instrução funciona:

1. Você olha a pia: tem louça? Sim → lava um prato.
2. Olha de novo: tem louça? Sim → lava mais um.
3. … e assim por diante …
4. Olha de novo: tem louça? Não → acabou, você vai fazer outra coisa.

Repare em três detalhes, porque eles valem para todo while:

• A pergunta vem antes de cada prato. Se a pia já estiver vazia, você não lava nenhum.
• Cada volta muda alguma coisa (um prato a menos). Sem isso, a pergunta teria sempre a mesma resposta.
• Quando a resposta vira não, você sai e continua com o resto do dia.

Em C++, a "pergunta" é uma condição, igual à do if: uma expressão que vale true (verdadeiro) ou false (falso). A diferença é que o if executa o bloco uma vez se a condição for verdadeira; o while executa de novo e de novo, enquanto ela continuar verdadeira.

1. O primeiro while: contar de 1 a 5

#include <iostream>

int main() {
    int i = 1;
    while (i <= 5) {
        std::cout << "Volta " << i << '\n';
        i++;
    }
    std::cout << "Fim! i agora vale " << i << '\n';
}

int i = 1;

A variável contadora, criada antes do laço, com o valor inicial. O nome i (de "índice") é uma tradição para contadores; poderia ser volta ou contador.

while

A palavra-chave do laço: "enquanto".

(i <= 5)

A condição, sempre entre parênteses. É testada antes de cada volta. Lê-se: "enquanto i for menor ou igual a 5" (os operadores estão em Comparação).

{ … }

O corpo do laço: as linhas que se repetem. Cada execução do corpo se chama uma volta (ou iteração).

i++;

Soma 1 ao contador (veja ++ e --). É esta linha que faz o laço andar: sem ela, i seria 1 para sempre.

$ g++ -std=c++23 -Wall -Wextra contar.cpp -o contar
$ ./contar
Volta 1
Volta 2
Volta 3
Volta 4
Volta 5
Fim! i agora vale 6

Passo a passo: o que o computador fez

Siga a variável i volta por volta. Este exercício de "ser o computador" é a melhor forma de entender laços:

Por isso a última linha mostra i agora vale 6: o laço só termina quando a condição fica falsa, e ela só fica falsa quando i passa de 5. A condição foi testada 6 vezes para o corpo rodar 5 vezes.

#include <iostream>

int main() {
    int i = 1;
    while (i <= 5) {
        std::cout << "Volta " << i << '\n';
        i++;
    }
    std::cout << "Fim! i agora vale " << i << '\n';
}

#include <iostream>

int main() {
    int i = 1;
    while (i <= 10) {
        std::cout << "Volta " << i << '\n';
        i++;
    }
    std::cout << "Fim! i agora vale " << i << '\n';
}

2. Contar para trás

O passo não precisa ser ++. Para uma contagem regressiva, comece do maior número, use -- e troque a condição para "maior que zero":

#include <iostream>

int main() {
    int segundos = 5;
    while (segundos > 0) {
        std::cout << segundos << "...\n";
        segundos--;
    }
    std::cout << "Já!\n";
}

$ g++ -std=c++23 -Wall -Wextra regressiva.cpp -o regressiva
$ ./regressiva
5...
4...
3...
2...
1...
Já!

Quando segundos chega a 0, a pergunta 0 > 0 é falsa e o laço termina. O Já! fica fora das chaves, então aparece uma vez só, no fim.

O passo também pode ser de 2 em 2 (i += 2), de 10 em 10, ou até uma multiplicação (valor *= 2), como você vai ver na missão final. Os atalhos += e *= estão em Operadores de Atribuição.

3. Acumular: somar de 1 até 100

Um uso clássico de laço é ir juntando um resultado. A técnica tem duas variáveis com papéis diferentes:

• o contador (n) diz em que volta estamos;
• o acumulador (soma) guarda o total até agora. Ele começa em 0 e, a cada volta, recebe mais um pouco.

#include <iostream>

int main() {
    int soma = 0;
    int n = 1;
    while (n <= 100) {
        soma += n;
        n++;
    }
    std::cout << "1 + 2 + ... + 100 = " << soma << '\n';
}

$ g++ -std=c++23 -Wall -Wextra soma100.cpp -o soma100
$ ./soma100
1 + 2 + ... + 100 = 5050

Nas primeiras voltas: soma vale 0, depois 0+1 = 1, depois 1+2 = 3, depois 3+3 = 6, depois 6+4 = 10… até chegar a 5050. Fazer isso à mão levaria um bom tempo; o computador faz as 100 voltas num piscar de olhos.

Quando você não sabe quantas voltas serão

O while brilha quando o número de voltas não é conhecido de antemão. A Ana guardou R$ 100 numa aplicação que rende 10% ao mês. Em quantos meses o dinheiro dobra?

#include <iostream>

int main() {
    double saldo = 100.0;
    int meses = 0;
    while (saldo < 200.0) {
        saldo = saldo * 1.10;
        meses++;
    }
    std::cout << "Dobrou em " << meses << " meses: R$ " << saldo << '\n';
}

$ g++ -std=c++23 -Wall -Wextra poupanca.cpp -o poupanca
$ ./poupanca
Dobrou em 8 meses: R$ 214.359

Aqui a condição não olha um contador, e sim o próprio saldo. A variável meses só conta as voltas para mostrar no fim. (Para mostrar 214,36 com duas casas, veja iomanip ou std::format.)

4. Repetir até o usuário digitar 0

Agora o programa vai conversar com a pessoa. A Ana quer somar os preços das compras: ela digita um preço por vez e, quando terminar, digita 0. Ninguém sabe quantos preços serão: é trabalho para o while.

#include <iostream>

int main() {
    int numero = 0;
    int soma = 0;
    std::cout << "Digite um número (0 para parar): ";
    std::cin >> numero;
    while (numero != 0) {
        soma += numero;
        std::cout << "Digite um número (0 para parar): ";
        std::cin >> numero;
    }
    std::cout << "Soma: " << soma << '\n';
}

std::cin >> numero;

A primeira leitura, antes do laço. Sem ela, o while não teria um número para testar (veja Entrada com cin).

while (numero != 0)

"Enquanto o número for diferente de zero." O 0 funciona como uma sentinela: um valor combinado que significa "acabou".

soma += numero;

Junta o número ao acumulador.

std::cin >> numero;

A leitura seguinte, no fim do corpo. É ela que muda a variável da condição. Depois dela, o laço volta para a pergunta numero != 0.

$ g++ -std=c++23 -Wall -Wextra soma.cpp -o soma
$ ./soma
Digite um número (0 para parar): 10
Digite um número (0 para parar): 25
Digite um número (0 para parar): 7
Digite um número (0 para parar): 0
Soma: 42

O 0 não entra na soma: assim que ele é lido, a condição fica falsa e o laço termina antes do soma += numero. E se a primeira coisa digitada for 0, o corpo nem roda: a resposta é Soma: 0.

Repare que a pergunta e o cin aparecem duas vezes (antes do laço e no fim do corpo). Isso funciona, mas é repetição. Há duas formas de escrever só uma vez, que você vai ver nas próximas aulas: o do-while (pergunta primeiro, testa depois) e o while (true) com break (break e continue).

#include <iostream>

int main() {
    int numero = 0;
    int soma = 0;
    std::cin >> numero;
    while (numero != 0) {
        soma += numero;
        std::cin >> numero;
    }
    std::cout << "Soma: " << soma << '\n';
}

#include <iostream>

int main() {
    int numero = 0;
    int soma = 0;
    int quantos = 0;
    std::cin >> numero;
    while (numero != 0) {
        soma += numero;
        quantos++;
        std::cin >> numero;
    }
    std::cout << "Você digitou " << quantos << " números.\n";
    std::cout << "Soma: " << soma << '\n';
}

5. Zero voltas: quando a condição já começa falsa

O while testa antes de entrar. Se a condição for falsa logo na primeira pergunta, o corpo não roda nenhuma vez, e o programa segue para a linha depois da }:

#include <iostream>

int main() {
    int estoque = 0;
    while (estoque > 0) {
        std::cout << "Vendendo uma unidade...\n";
        estoque--;
    }
    std::cout << "Acabou o estoque.\n";
}

$ g++ -std=c++23 -Wall -Wextra nunca.cpp -o nunca
$ ./nunca
Acabou o estoque.

Isso não é erro: é exatamente o que você quer numa lojinha sem estoque. Quando precisar que o corpo rode pelo menos uma vez, a ferramenta é o do-while.

6. O laço infinito

Se a condição nunca ficar falsa, o laço nunca termina. Isso se chama laço infinito, e o motivo mais comum é esquecer o passo. Neste programa, falta o i++, então i vale 1 para sempre e 1 <= 5 é sempre verdadeiro:

#include <iostream>

int main() {
    int i = 1;
    long long voltas = 0;
    std::cout << "Somando..." << std::endl;
    while (i <= 5) {
        voltas++;
    }
    std::cout << "Fim\n";
}

O compilador não reclama: um laço infinito é um programa válido (às vezes ele é até de propósito, como num jogo que roda até o jogador sair). O problema só aparece ao rodar: o programa mostra Somando... e fica parado, com o processador trabalhando a 100%, sem nunca chegar ao Fim.

Como parar: Ctrl+C

No terminal, aperte Ctrl+C. O terminal manda um aviso de "interromper" ao programa, que é encerrado na hora. O echo $? mostra o código de saída do último programa; 130 quer dizer "interrompido por Ctrl+C":

$ ./infinito2
Somando...
^C                      « aqui a Ana apertou Ctrl+C
$ echo $?
130

Como testar sem medo: timeout

Quando você suspeita que um programa pode travar, rode-o com o comando timeout, que dá um prazo em segundos e encerra o programa se ele passar disso. É assim que os laços infinitos deste guia foram testados:

$ timeout 3 ./infinito2
Somando...                « e 3 segundos de espera
$ echo $?
124

O código 124 é o jeito do timeout dizer "o prazo acabou e eu tive que encerrar o programa". Se o programa tivesse terminado sozinho a tempo, o código seria o dele (normalmente 0).

Como evitar

Antes de rodar um while, faça a si mesmo três perguntas:

1. O que muda a cada volta? Alguma linha do corpo precisa mudar uma variável que aparece na condição (i++, segundos--, um novo std::cin >> numero).
2. A mudança vai na direção certa? Com while (i <= 5), o i precisa subir. Um i-- por engano faria i descer para sempre.
3. O valor de parada é alcançável? Com while (i != 10) e i += 3 começando do 1, o i passa por 1, 4, 7, 10: para. Começando do 0, passa por 0, 3, 6, 9, 12… e pula o 10. Prefira < e <= a != em contadores.

Há também laços infinitos de propósito: while (true) { … }. Eles têm uma saída escondida no meio do corpo, o break. Isso tem aula própria: break e continue.

Formas diferentes de escrever

Chaves num laço de uma linha

Como no if, se o corpo tiver uma única instrução, as chaves podem ser omitidas:

while (segundos > 0)
    std::cout << segundos-- << "...\n";

Funciona, mas é fácil acrescentar uma segunda linha achando que ela está dentro do laço. Use sempre as chaves: é o que este guia faz.

Onde fazer o passo

i++ numa linha separada (como nos exemplos) é a forma mais clara. Também existe std::cout << i++;, que mostra e soma ao mesmo tempo. Para quem está começando, uma coisa por linha.

Qual laço usar?

Quando dá errado

$ timeout 3 ./infinito2
Somando...
$ echo $?
124

#include <iostream>

int main() {
    int i = 1;
    while (i <= 5); {
        std::cout << i << '\n';
        i++;
    }
}

$ g++ -std=c++23 -Wall -Wextra pontovirgula.cpp -o pontovirgula
pontovirgula.cpp: In function ‘int main()’:
pontovirgula.cpp:5:5: warning: this ‘while’ clause does not guard... [-Wmisleading-indentation]
    5 |     while (i <= 5); {
      |     ^~~~~
pontovirgula.cpp:5:21: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘while’
    5 |     while (i <= 5); {
      |                     ^
$ timeout 3 ./pontovirgula
$ echo $?
124

#include <iostream>

int main() {
    int numero = 5;
    while (numero = 0) {
        std::cout << numero << '\n';
        numero--;
    }
    std::cout << "Fim\n";
}

$ g++ -std=c++23 -Wall -Wextra igual.cpp -o igual
igual.cpp: In function ‘int main()’:
igual.cpp:5:19: warning: suggest parentheses around assignment used as truth value [-Wparentheses]
    5 |     while (numero = 0) {
      |            ~~~~~~~^~~
$ ./igual
Fim

#include <iostream>

int main() {
    int n = 1;
    while (n <= 3) {
        int soma = 0;
        soma += n;
        std::cout << "Soma até agora: " << soma << '\n';
        n++;
    }
}

$ g++ -std=c++23 -Wall -Wextra zera.cpp -o zera
$ ./zera
Soma até agora: 1
Soma até agora: 2
Soma até agora: 3

Referência

Exercícios

Missão final: dobrar até passar de 1000

#include <iostream>

int main() {
    int valor = 1;
    // escreva o while aqui

}

#include <iostream>

int main() {
    int valor = 1;
    while (valor < 1000) {
        std::cout << valor << '\n';
        valor *= 2;
    }
}

Resumo

• while (condição) { corpo } repete o corpo enquanto a condição for verdadeira. A condição é testada antes de cada volta, então o corpo pode rodar 0 vezes.
• Todo laço com contador tem três peças: início (int i = 1;), condição (i <= 5) e passo (i++).
• Um acumulador (soma) nasce fora do laço, valendo 0, e cresce dentro dele.
• Para ler até uma sentinela (o 0): leia uma vez antes do laço e de novo no fim do corpo.
• Se nada muda a condição, o laço é infinito: pare com Ctrl+C e teste com timeout 3 (código 124).
• Nada de ; logo depois de while ( … ), e = não é ==: o -Wall avisa os dois.