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 em inglês quer dizer "enquanto": enquanto a condição for verdadeira, repita.

Todos os programas desta aula foram compilados com o gcc 15 na máquina fictícia da Ana (usuária ana, computador notebook), na pasta ~/c, com o comando padrão do guia: gcc -std=c23 -Wall -Wextra arquivo.c -o programa (veja Compilar com gcc). 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 dá verdadeiro ou falso. Em C, falso é o número 0 e verdadeiro é qualquer outro número. 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 <stdio.h>

int main(void) {
    int i = 1;
    while (i <= 5) {
        printf("Volta %d\n", i);
        i++;
    }
    printf("Fim! i agora vale %d\n", i);
    return 0;
}

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 Operadores de Comparação).

{ … }

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

printf("Volta %d\n", i);

Mostra o valor atual de i no lugar do %d (veja Formatos do printf).

i++;

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

$ gcc -std=c23 -Wall -Wextra contar.c -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 <stdio.h>

int main(void) {
    int i = 1;
    while (i <= 5) {
        printf("Volta %d\n", i);
        i++;
    }
    printf("Fim! i agora vale %d\n", i);
    return 0;
}

#include <stdio.h>

int main(void) {
    int i = 1;
    while (i <= 10) {
        printf("Volta %d\n", i);
        i++;
    }
    printf("Fim! i agora vale %d\n", i);
    return 0;
}

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 <stdio.h>

int main(void) {
    int segundos = 5;
    while (segundos > 0) {
        printf("%d...\n", segundos);
        segundos--;
    }
    printf("Já!\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra regressiva.c -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 <stdio.h>

int main(void) {
    int soma = 0;
    int n = 1;
    while (n <= 100) {
        soma += n;
        n++;
    }
    printf("1 + 2 + ... + 100 = %d\n", soma);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra soma100.c -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 <stdio.h>

int main(void) {
    double saldo = 100.0;
    int meses = 0;
    while (saldo < 200.0) {
        saldo = saldo * 1.10;
        meses++;
    }
    printf("Dobrou em %d meses: R$ %.2f\n", meses, saldo);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra poupanca.c -o poupanca
$ ./poupanca
Dobrou em 8 meses: R$ 214.36

Aqui a condição não olha um contador, e sim o próprio saldo (um double, veja float e double). A variável meses só conta as voltas para mostrar no fim. O %.2f mostra o número com duas casas depois do ponto.

4. Somar números 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 número por vez e, quando terminar, digita 0. Ninguém sabe quantos números serão: é trabalho para o while. A leitura é feita com scanf ("scan formatted", ler formatado; veja Entrada com scanf).

#include <stdio.h>

int main(void) {
    int numero = 0;
    int soma = 0;
    printf("Digite um número (0 para parar): ");
    scanf("%d", &numero);
    while (numero != 0) {
        soma += numero;
        printf("Digite um número (0 para parar): ");
        scanf("%d", &numero);
    }
    printf("Soma: %d\n", soma);
    return 0;
}

scanf("%d", &numero);

A primeira leitura, antes do laço. Sem ela, o while não teria um número para testar. O & antes do nome diz ao scanf onde guardar o número.

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.

scanf("%d", &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.

$ gcc -std=c23 -Wall -Wextra soma.c -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 scanf aparecem duas vezes (antes do laço e no fim do corpo). Isso funciona, mas é repetição. Logo abaixo você vê uma forma mais curta, e nas próximas aulas mais duas: o do while (pergunta primeiro, testa depois) e o laço infinito com break (break e continue).

#include <stdio.h>

int main(void) {
    int numero = 0;
    int soma = 0;
    printf("Digite um número (0 para parar): ");
    scanf("%d", &numero);
    while (numero != 0) {
        soma += numero;
        printf("Digite um número (0 para parar): ");
        scanf("%d", &numero);
    }
    printf("Soma: %d\n", soma);
    return 0;
}

#include <stdio.h>

int main(void) {
    int numero = 0;
    int soma = 0;
    int quantos = 0;
    printf("Digite um número (0 para parar): ");
    scanf("%d", &numero);
    while (numero != 0) {
        soma += numero;
        quantos++;
        printf("Digite um número (0 para parar): ");
        scanf("%d", &numero);
    }
    printf("Você digitou %d números.\n", quantos);
    printf("Soma: %d\n", soma);
    return 0;
}

E se a Ana digitar uma letra?

O scanf("%d", …) espera um número. Se a pessoa digitar abc, ele não consegue ler, deixa o abc parado na entrada e não muda a variável. Na volta seguinte, tenta de novo, encontra o mesmo abc, falha de novo… e o laço nunca termina, porque numero continua valendo 10:

$ ./soma
Digite um número (0 para parar): 10
Digite um número (0 para parar): abc
Digite um número (0 para parar): Digite um número (0 para parar): Digite um número (0 para parar): Digite um número (0 para parar): Digite um número (0 para parar): Digite um núm
^C                      « a pergunta se repete sem parar até a Ana apertar Ctrl+C

A defesa é conferir o que o scanf devolve: o número de valores que ele conseguiu ler. Com um %d, o certo é 1. Colocando a leitura dentro da condição, ela aparece uma vez só, e o laço também para quando a leitura falha:

#include <stdio.h>

int main(void) {
    int numero = 0;
    int soma = 0;
    printf("Digite um número (0 para parar): ");
    while (scanf("%d", &numero) == 1 && numero != 0) {
        soma += numero;
        printf("Digite um número (0 para parar): ");
    }
    printf("Soma: %d\n", soma);
    return 0;
}

scanf("%d", &numero) == 1

Tenta ler um número e confere se deu certo. É feito em toda pergunta do laço, inclusive a primeira.

&&

"E" (veja Operadores Lógicos). Só se a leitura deu certo o C olha a segunda parte.

numero != 0

A sentinela, como antes.

$ gcc -std=c23 -Wall -Wextra soma2.c -o soma2
$ ./soma2
Digite um número (0 para parar): 10
Digite um número (0 para parar): abc
Soma: 10

Agora uma letra encerra a soma em vez de travar o programa. (Avisar "isso não é um número, tente de novo" dá um pouco mais de trabalho: está em Validar a Entrada.)

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 <stdio.h>

int main(void) {
    int estoque = 0;
    while (estoque > 0) {
        printf("Vendendo uma unidade...\n");
        estoque--;
    }
    printf("Acabou o estoque.\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra nunca.c -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 <stdio.h>

int main(void) {
    int i = 1;
    int dobro = 0;
    printf("Calculando...\n");
    while (i <= 5) {
        dobro = i * 2;
    }
    printf("Último dobro: %d\n", dobro);
    return 0;
}

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 Calculando... e fica parado, com o processador trabalhando a 100%, sem nunca chegar ao Último dobro.

Como parar no terminal: 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":

$ gcc -std=c23 -Wall -Wextra infinito.c -o infinito
$ ./infinito
Calculando...
^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 ./infinito
Calculando...            « 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 parar no editor do guia: botão Parar (ou 15 segundos)

No editor, enquanto o programa roda, o botão Rodar vira ■ Parar. Clicar nele é o Ctrl+C do editor: aparece ^C e [código de saída: 130], como no terminal. Se você não fizer nada, o editor para o programa sozinho depois de 15 segundos rodando e mostra:

(o editor parou o programa: ele rodou mais de 15 segundos sem terminar — laço infinito?)
[programa interrompido]

Os 15 segundos contam só o tempo em que o programa está trabalhando. O tempo em que ele está esperando você digitar não conta.

#include <stdio.h>

int main(void) {
    int i = 1;
    int dobro = 0;
    printf("Calculando...\n");
    while (i <= 5) {
        dobro = i * 2;
    }
    printf("Último dobro: %d\n", dobro);
    return 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 scanf).
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.

Laço infinito de propósito: while (1) e while (true)

Às vezes você quer um laço sem fim, com uma saída escondida no meio do corpo, o break (aula break e continue). Como em C qualquer número diferente de zero é verdadeiro, a forma tradicional é while (1). No C23, true virou palavra da linguagem e while (true) também funciona C23. Num padrão antigo, o gcc não conhece o true sem o #include <stdbool.h>:

$ gcc -std=c17 -Wall -Wextra verdade.c -o verdade
verdade.c: In function ‘main’:
verdade.c:5:12: error: ‘true’ undeclared (first use in this function)
    5 |     while (true) {
      |            ^~~~
verdade.c:2:1: note: ‘true’ is defined in header ‘<stdbool.h>’; this is probably fixable by adding ‘#include <stdbool.h>’
    1 | #include <stdio.h>
  +++ |+#include <stdbool.h>
    2 | 

Com -std=c23 (ou sem -std, no gcc 15) o mesmo arquivo compila. Mais sobre isso em Booleanos.

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)
    printf("%d...\n", segundos--);

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 printf("%d\n", i++);, que mostra e soma ao mesmo tempo. Para quem está começando, uma coisa por linha.

Qual laço usar?

Quando dá errado

#include <stdio.h>

int main(void) {
    int i = 1;
    while (i <= 5) {
        printf("Volta %d\n", i);
    }
    printf("Fim\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra esqueci.c -o esqueci
$ ./esqueci
Volta 1
Volta 1
Volta 1
Volta 1
Volta 1
^C                      « milhares de linhas depois, a Ana apertou Ctrl+C

#include <stdio.h>

int main(void) {
    int i = 1;
    while (i <= 5); {
        printf("%d\n", i);
        i++;
    }
    return 0;
}

$ gcc -std=c23 -Wall -Wextra pontovirgula.c -o pontovirgula
pontovirgula.c: In function ‘main’:
pontovirgula.c:5:5: warning: this ‘while’ clause does not guard... [-Wmisleading-indentation]
    5 |     while (i <= 5); {
      |     ^~~~~
pontovirgula.c: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 <stdio.h>

int main(void) {
    int numero = 5;
    while (numero = 0) {
        printf("%d\n", numero);
        numero--;
    }
    printf("Fim\n");
    return 0;
}

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

#include <stdio.h>

int main(void) {
    int n = 1;
    while (n <= 3) {
        int soma = 0;
        soma += n;
        printf("Soma até agora: %d\n", soma);
        n++;
    }
    return 0;
}

$ gcc -std=c23 -Wall -Wextra zera.c -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 <stdio.h>

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

    return 0;
}

#include <stdio.h>

int main(void) {
    int valor = 1;
    while (valor < 1000) {
        printf("%d\n", valor);
        valor *= 2;
    }
    return 0;
}

Resumo

• while (condição) { corpo } repete o corpo enquanto a condição for verdadeira (diferente de 0). 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), confira também o retorno do scanf: while (scanf("%d", &x) == 1 && x != 0).
• Se nada muda a condição, o laço é infinito: pare com Ctrl+C no terminal (código 130), com ■ Parar no editor (que para sozinho em 15 s) e teste com timeout 3 (código 124).
• Nada de ; logo depois de while ( … ), e = não é ==: o -Wall avisa os dois.