Capítulo 14 — Loops com while

Série: Do zero ao jogo comercial com C++ e SFML

1 de set de 2026

Nosso programa já sabe escolher. Agora ele precisa aprender a repetir ações enquanto uma condição permanecer verdadeira.

Nos últimos capítulos nosso programa evoluiu bastante.

Ele começou apenas executando instruções em sequência.

Depois aprendeu a armazenar estado:

  int playerHealth = 100;
int playerCoins = 25;

Aprendeu a representar melhor diferentes informações:

  float playerSpeed = 4.5f;
bool isAlive = true;

Passou a utilizar constantes:

  const int MAX_PLAYER_HEALTH = 100;

Começou a transformar dados:

  playerHealth -= 20;
playerCoins += 10;

Aprendeu a construir expressões:

  int finalDamage = (baseDamage + bonusDamage) * criticalMultiplier;

Depois passou a tomar decisões:

  if (playerHealth <= 0)
{
    std::cout << "Player defeated." << std::endl;
}

Aprendeu alternativas com:

  if (...)
{
}
else
{
}

e múltiplas opções com:

  switch (...)
{
}

Por fim, começamos a utilizar tipos mais expressivos:

  enum class Season
{
    Spring,
    Summer,
    Autumn,
    Winter
};

Mas nosso programa ainda possui uma limitação enorme.

Ele executa cada instrução uma vez, a menos que nós mesmos a repitamos no código.

Imagine que queremos mostrar cinco dias:

  Day 1
Day 2
Day 3
Day 4
Day 5

Poderíamos escrever:

  std::cout << "Day 1" << std::endl;
std::cout << "Day 2" << std::endl;
std::cout << "Day 3" << std::endl;
std::cout << "Day 4" << std::endl;
std::cout << "Day 5" << std::endl;

Funciona.

Mas e se fossem:

  10 dias?
100 dias?
1000 atualizações?

Copiar e colar instruções claramente não é uma boa solução.

Precisamos ensinar nosso programa a:

repetir uma ação enquanto uma condição permanecer verdadeira.

É aqui que entra:

  while

1. Começando pelo problema

Queremos produzir:

  Day 1
Day 2
Day 3
Day 4
Day 5

Sem repetir manualmente cinco std::cout.

Precisamos de alguma informação que represente:

  dia atual

Podemos começar:

  int day = 1;

Também precisamos saber até quando repetir.

  const int TOTAL_DAYS = 5;

Nossa regra pode ser descrita assim:

  ENQUANTO day for menor ou igual a TOTAL_DAYS

    mostrar o dia atual
    avançar para o próximo dia

Essa frase já está muito próxima do código que escreveremos.

2. Conhecendo `while`

A estrutura fundamental é:

  while (condition)
{
    // código repetido
}

Podemos ler:

enquanto a condição for verdadeira, execute o bloco.

Ou conceitualmente:

  avaliar condição
      │
      ├── true
      │     ↓
      │ executar bloco
      │     ↓
      │ voltar à condição
      │
      └── false
            ↓
         sair do loop

Essa repetição é chamada de loop.

3. Nosso primeiro `while`

  #include <iostream>

int main()
{
    int day = 1;
    const int TOTAL_DAYS = 5;

    while (day <= TOTAL_DAYS)
    {
        std::cout << "Day " << day << std::endl;

        day++;
    }

    return 0;
}

Resultado esperado:

  Day 1
Day 2
Day 3
Day 4
Day 5

Conseguimos repetir uma ação sem escrever cinco vezes o mesmo std::cout.

4. Vamos desmontar o loop

Temos:

  int day = 1;

Esse é o estado inicial.

Depois:

  while (day <= TOTAL_DAYS)

Essa é a condição que decide se o loop continua.

Dentro:

  std::cout << "Day " << day << std::endl;

Essa é a ação repetida.

Depois:

  day++;

Atualizamos o estado.

Podemos visualizar:

  INICIALIZAÇÃO
day = 1
    ↓
CONDIÇÃO
day <= TOTAL_DAYS?
    ↓ true
AÇÃO
mostrar day
    ↓
ATUALIZAÇÃO
day++
    ↓
voltar para a condição

Até que a condição se torne falsa.

5. Primeira iteração

Começamos:

  day = 1
TOTAL_DAYS = 5

A condição:

  day <= TOTAL_DAYS

vira:

  1 <= 5

Resultado:

  true

Então executamos:

  std::cout << "Day " << day << std::endl;

Saída:

  Day 1

Depois:

  day++;

Agora:

  day = 2

6. Segunda iteração

Voltamos para:

  while (day <= TOTAL_DAYS)

Agora:

  2 <= 5

Resultado:

  true

Executamos:

  Day 2

Depois:

  day++;

Agora:

  day = 3

O mesmo processo continua.

7. Quando o loop termina?

Depois de mostrar:

  Day 5

executamos:

  day++;

Então:

  day = 6

Voltamos para a condição:

  6 <= 5

Resultado:

  false

Agora o corpo do while não é executado novamente.

O programa continua depois do loop.

8. Podemos mostrar isso explicitamente

  #include <iostream>

int main()
{
    int day = 1;
    const int TOTAL_DAYS = 5;

    while (day <= TOTAL_DAYS)
    {
        std::cout << "Day " << day << std::endl;

        day++;
    }

    std::cout << "Simulation finished." << std::endl;

    return 0;
}

Resultado:

  Day 1
Day 2
Day 3
Day 4
Day 5
Simulation finished.

Agora fica claro que o programa sai do loop quando a condição se torna falsa.

9. Loop significa repetição controlada

A palavra importante não é apenas:

  repetição

É:

  repetição controlada

Temos:

  estado
+
condição
+
ação
+
atualização

Essas partes controlam o comportamento.

Se uma delas estiver errada, o loop pode produzir resultados inesperados.

10. A condição é uma expressão booleana

Assim como no if, temos:

  day <= TOTAL_DAYS

Essa expressão produz:

  true

ou:

  false

O while não precisa de um tipo especial de condição.

Ele utiliza uma expressão booleana.

Portanto:

  while (day <= TOTAL_DAYS)

funciona conceitualmente como:

  enquanto essa expressão produzir true
→ continue repetindo

11. `while` testa antes de executar

Essa característica é muito importante.

Considere:

  int day = 10;
const int TOTAL_DAYS = 5;

Agora:

  while (day <= TOTAL_DAYS)
{
    std::cout << "Day " << day << std::endl;

    day++;
}

Antes de executar o bloco pela primeira vez, o programa testa:

  10 <= 5

Resultado:

  false

Então o corpo do loop executa:

  zero vezes

12. Um `while` pode não executar nenhuma vez

Esse é um ponto fundamental.

while significa:

teste a condição primeiro.

Se ela já começar falsa:

  0 iterações

Isso pode ser exatamente o comportamento que queremos.

Por exemplo:

  int itemsToProcess = 0;

while (itemsToProcess > 0)
{
    // processar item
}

Se não existem itens, não há nada para repetir.

13. O que é uma iteração?

Cada execução completa do corpo do loop é chamada de iteração.

No nosso exemplo:

  Day 1 → iteração 1
Day 2 → iteração 2
Day 3 → iteração 3
Day 4 → iteração 4
Day 5 → iteração 5

Então:

  while (day <= TOTAL_DAYS)

executou:

  5 iterações

Esse termo aparecerá muitas vezes daqui para a frente.

14. O contador

Nossa variável:

  int day = 1;

também está funcionando como um contador.

Ela ajuda a controlar:

  em qual repetição estamos

A cada iteração:

  day++;

faz:

  1 → 2 → 3 → 4 → 5 → 6

Quando chega a 6, a condição deixa de ser verdadeira.

15. A atualização é essencial

Agora remova:

  day++;

Teremos:

  #include <iostream>

int main()
{
    int day = 1;
    const int TOTAL_DAYS = 5;

    while (day <= TOTAL_DAYS)
    {
        std::cout << "Day " << day << std::endl;
    }

    return 0;
}

O que acontece?

Começamos:

  day = 1

Testamos:

  1 <= 5
→ true

Imprimimos:

  Day 1

Voltamos.

Mas:

day

continua sendo:

Então:

  1 <= 5
→ true

de novo.

E de novo.

16. Criamos um loop infinito

Nosso programa continua repetindo:

  Day 1
Day 1
Day 1
Day 1
Day 1
...

porque nada faz a condição se tornar falsa.

Isso é um infinite loop, ou loop infinito.

Conceitualmente:

  condição verdadeira
↓
executa
↓
estado não muda
↓
condição continua verdadeira
↓
executa
↓
...

17. Loop infinito não significa necessariamente "travamento"

Um programa em loop infinito continua executando.

Dependendo do que ele faz, pode parecer que:

  travou

Mas talvez esteja apenas repetindo algo indefinidamente.

Em nosso exemplo, o console pode continuar recebendo:

  Day 1
Day 1
Day 1
...

Isso é diferente de um processo que deixou completamente de executar.

18. Como interromper durante o desenvolvimento

Se você criar acidentalmente um loop infinito no Visual Studio, interrompa a execução pelo próprio ambiente de depuração/console conforme a forma utilizada para iniciar o programa.

Depois investigue.

Não simplesmente reinicie e repita o mesmo código.

Pergunte:

  Qual é a condição?

Qual estado influencia essa condição?

Esse estado está sendo atualizado?

Existe algum caminho que torne a condição falsa?

Esse é o raciocínio importante.

19. Método para investigar loops infinitos

Podemos utilizar:

  1. Identificar a condição.

2. Identificar as variáveis usadas nela.

3. Observar o valor inicial.

4. Encontrar onde esses valores mudam.

5. Simular algumas iterações manualmente.

6. Verificar se a condição pode se tornar falsa.

No nosso caso:

  condition:
day <= TOTAL_DAYS

day começa:
1

TOTAL_DAYS:
5

day muda?
não

logo:
1 <= 5 será sempre true

Encontramos a causa.

20. Restaurando a atualização

  while (day <= TOTAL_DAYS)
{
    std::cout << "Day " << day << std::endl;

    day++;
}

Agora:

  day
1 → 2 → 3 → 4 → 5 → 6

  6 <= 5
→ false

O loop termina.

21. A atualização não precisa ser `++`

Podemos escrever:

  day = day + 1;

ou:

  day += 1;

ou:

  day++;

No contexto atual, todas podem representar o avanço de uma unidade.

Vamos utilizar:

  day++;

porque já aprendemos o operador de incremento e ele comunica claramente a intenção.

22. O estado pode mudar de outras formas

Um while não exige obrigatoriamente um contador.

Imagine:

  bool isRunning = true;

while (isRunning)
{
    // repetir enquanto isRunning for true
}

Agora a continuidade do loop depende de:

  isRunning

e não de um número.

Isso começa a ficar interessante para jogos.

Mas ainda não vamos construir nosso Game Loop.

23. Um vislumbre do futuro

Um jogo real possui algo conceitualmente parecido com:

  enquanto o jogo estiver rodando

    processar eventos
    atualizar estado
    renderizar

Talvez algo como:

  while (isRunning)
{
    // process input
    // update game
    // render
}

Mas ainda não temos:

  window
input
rendering
time
SFML

Então não vamos fingir que já temos um Game Loop completo.

Primeiro estamos aprendendo o mecanismo básico de repetição.

24. `while` e estado trabalham juntos

Considere:

  int energy = 5;

while (energy > 0)
{
    std::cout << "Energy: " << energy << std::endl;

    energy--;
}

Resultado:

  Energy: 5
Energy: 4
Energy: 3
Energy: 2
Energy: 1

Depois:

  energy = 0

  0 > 0
→ false

O loop termina.

25. Outro exemplo contextual: recursos produzidos

Podemos simular uma produção simples:

  #include <iostream>

int main()
{
    int producedResources = 0;
    const int TARGET_RESOURCES = 5;

    while (producedResources < TARGET_RESOURCES)
    {
        producedResources++;

        std::cout << "Resources Produced: " << producedResources << std::endl;
    }

    return 0;
}

Resultado:

  Resources Produced: 1
Resources Produced: 2
Resources Produced: 3
Resources Produced: 4
Resources Produced: 5

Ainda não existe um sistema real de produção.

O exemplo apenas mostra outra condição de repetição.

26. A posição da atualização altera o resultado

Compare:

  while (producedResources < TARGET_RESOURCES)
{
    producedResources++;

    std::cout << producedResources << std::endl;
}

com:

  while (producedResources < TARGET_RESOURCES)
{
    std::cout << producedResources << std::endl;

    producedResources++;
}

Se:

  producedResources = 0

a primeira versão imprime:

A segunda:

O loop pode executar a mesma quantidade de vezes, mas o momento da atualização muda o valor observado.

27. Erros de limite começam a aparecer

Imagine que queremos:

  Day 1
Day 2
Day 3
Day 4
Day 5

Escrevemos:

  while (day < TOTAL_DAYS)

Com:

  day = 1
TOTAL_DAYS = 5

Teremos:

Mas:

  5 < 5
→ false

Saída:

  Day 1
Day 2
Day 3
Day 4

O Day 5 desapareceu.

28. `<` e `<=` mudam a fronteira

Compare:

  while (day < TOTAL_DAYS)

com:

  while (day <= TOTAL_DAYS)

Para:

  day = 1
TOTAL_DAYS = 5

temos:

  <  → 1, 2, 3, 4

<= → 1, 2, 3, 4, 5

Uma única igualdade muda o conjunto de iterações.

Esse tipo de problema é muito comum em loops.

29. Off-by-one errors

Erros em que executamos uma iteração a mais ou a menos são frequentemente chamados de:

off-by-one errors.

Exemplo:

  esperado:
5 iterações

obtido:
4

ou:

  esperado:
5

obtido:
6

Eles podem surgir por diferenças como:

  <
<=
>
>=

ou por valor inicial incorreto.

30. Teste as bordas do loop

Para:

  while (day <= TOTAL_DAYS)

com:

  day = 1
TOTAL_DAYS = 5

verifique:

  primeiro valor:
1

último valor válido:
5

primeiro valor inválido:
6

Temos:

  1 <= 5 → true
5 <= 5 → true
6 <= 5 → false

Esse pequeno raciocínio já ajuda a evitar muitos erros.

31. O valor inicial também importa

Considere:

  int day = 0;
const int TOTAL_DAYS = 5;

while (day <= TOTAL_DAYS)
{
    std::cout << "Day " << day << std::endl;

    day++;
}

Resultado:

  Day 0
Day 1
Day 2
Day 3
Day 4
Day 5

Temos seis iterações.

Talvez:

  Day 0

não faça sentido para nosso exemplo.

Então o problema não estava apenas na condição.

Também estava no estado inicial.

32. Um loop é a combinação de várias decisões

Cada iteração começa perguntando:

  a condição ainda é verdadeira?

Então, conceitualmente:

  while

utiliza repetidamente a mesma ideia booleana que aprendemos com:

if

A diferença é:

  if
→ avalia e segue adiante

enquanto:

  while
→ avalia
→ executa
→ volta
→ avalia novamente

Essa repetição da decisão é o coração do loop.

33. `if` dentro de `while`

Como já conhecemos decisões, podemos combinar os conceitos.

Exemplo:

  #include <iostream>

int main()
{
    int day = 1;
    const int TOTAL_DAYS = 5;

    while (day <= TOTAL_DAYS)
    {
        std::cout << "Day " << day << std::endl;

        if (day == 3)
        {
            std::cout << "Special event." << std::endl;
        }

        day++;
    }

    return 0;
}

Resultado:

  Day 1
Day 2
Day 3
Special event.
Day 4
Day 5

Agora temos uma decisão acontecendo dentro de cada repetição.

34. Não confunda repetição com duplicação de lógica

O loop existe para repetir uma regra.

Não para esconder código enorme dentro dele.

Por exemplo, não devemos pensar:

  while existe
↓
coloque todo o jogo dentro de um bloco gigantesco

Mais tarde nosso código será organizado em funções, classes e sistemas.

O loop coordenará comportamentos.

Não será uma desculpa para concentrar tudo em um único lugar.

35. Ainda não precisamos de funções

Talvez nosso main.cpp já esteja começando a crescer.

Isso é proposital.

Quando chegarmos ao Capítulo 17, o problema de organização ficará mais evidente.

Por enquanto precisamos enxergar:

  repetição
condição
atualização

sem esconder esses conceitos dentro de funções prematuramente.

36. Ainda não precisamos de SFML

Poderíamos tentar criar agora:

  while (window.isOpen())
{
}

Mas isso introduziria:

  SFML
Window
Events
Rendering
Lifecycle

antes de termos aprendido o loop isoladamente.

Não faremos isso.

Quando chegarmos à janela gráfica, o while já será um conceito conhecido.

Então poderemos nos concentrar no novo problema.

37. Microdesafio — dias

Crie:

  int day = 1;
const int TOTAL_DAYS = 7;

Utilize while para mostrar:

  Day 1
Day 2
Day 3
Day 4
Day 5
Day 6
Day 7

Tente antes de olhar uma possível solução.

38. Uma possível solução

  int day = 1;
const int TOTAL_DAYS = 7;

while (day <= TOTAL_DAYS)
{
    std::cout << "Day " << day << std::endl;

    day++;
}

Valide:

  primeiro:
1

último:
7

depois:
8 <= 7
→ false

39. Microdesafio — energia

Comece:

  int energy = 5;

Enquanto:

  energy > 0

mostre o valor e diminua uma unidade.

Resultado:

  Energy: 5
Energy: 4
Energy: 3
Energy: 2
Energy: 1

Uma possível solução:

  while (energy > 0)
{
    std::cout << "Energy: " << energy << std::endl;

    energy--;
}

40. Microdesafio — evento no terceiro dia

Utilize:

  int day = 1;
const int TOTAL_DAYS = 5;

Dentro do while, quando:

  day == 3

mostre:

  Special event.

Resultado:

  Day 1
Day 2
Day 3
Special event.
Day 4
Day 5

Você já possui todo o conhecimento necessário.

41. Erro proposital — loop infinito

Crie temporariamente:

  int day = 1;
const int TOTAL_DAYS = 5;

while (day <= TOTAL_DAYS)
{
    std::cout << "Day " << day << std::endl;
}

Execute apenas o suficiente para observar o problema.

Interrompa.

Depois responda:

  Qual variável controla a condição?

Ela está mudando?

O que deveria fazê-la alcançar 6?

Por que a condição nunca fica false?

Finalmente restaure:

  day++;

42. Erro proposital — condição falsa desde o início

Teste:

  int day = 10;
const int TOTAL_DAYS = 5;

while (day <= TOTAL_DAYS)
{
    std::cout << "Day " << day << std::endl;

    day++;
}

O bloco não deve executar.

Isso não é um bug.

É a consequência correta de uma condição que começou falsa.

43. Erro proposital — um dia a menos

Teste:

  int day = 1;
const int TOTAL_DAYS = 5;

while (day < TOTAL_DAYS)
{
    std::cout << "Day " << day << std::endl;

    day++;
}

Resultado:

  Day 1
Day 2
Day 3
Day 4

Agora troque:

por:

<=

e explique por que Day 5 aparece.

44. Código final do capítulo

Vamos manter uma pequena simulação de dias com um evento intermediário:

  #include <iostream>

int main()
{
    int day = 1;
    const int TOTAL_DAYS = 5;

    std::cout << "=== SIMULATION START ===" << std::endl;

    while (day <= TOTAL_DAYS)
    {
        std::cout << "Day " << day << std::endl;

        if (day == 3)
        {
            std::cout << "A special event happened." << std::endl;
        }

        day++;
    }

    std::cout << "Simulation finished." << std::endl;

    return 0;
}

Resultado esperado:

  === SIMULATION START ===
Day 1
Day 2
Day 3
A special event happened.
Day 4
Day 5
Simulation finished.

45. O que esse código representa?

Temos:

  estado inicial
↓
day = 1

Depois:

  condição de continuidade
↓
day <= TOTAL_DAYS

Dentro:

  ação repetida
↓
mostrar o dia

Também:

  decisão durante a iteração
↓
day == 3?

Finalmente:

  atualização
↓
day++

Isso já nos dá um pequeno modelo de simulação.

46. A arquitetura continua mínima

Nossa estrutura ainda pode continuar:

  CppGameEngine/
└── main.cpp

Não precisamos criar:

  LoopManager
SimulationManager
DaySystem
IterationService

Estamos apenas aprendendo um mecanismo fundamental da linguagem.

Quando o sistema real de tempo existir, teremos problemas concretos muito diferentes.

47. Validando a implementação

Salve:

  Ctrl + S

Faça Build:

  Ctrl + Shift + B

Confirme:

  Build succeeded

Execute:

  Ctrl + F5

Valide:

  Day 1
Day 2
Day 3
evento
Day 4
Day 5
fim

Depois faça os testes de borda.

48. Cenários de validação

Use pelo menos estes cenários:

Estado inicialLimiteResultado esperado155 iterações551 iteração650 iterações111 iteração

Esses casos ajudam a verificar a fronteira da condição.

49. Cenário especial: limite zero

Considere:

  int day = 1;
const int TOTAL_DAYS = 0;

A condição:

  1 <= 0

começa falsa.

Portanto:

  0 iterações

Isso é coerente com nossa regra.

50. Checklist de compreensão

Antes de avançar, tente responder:

O que é um loop?
Para que serve while?
Quando a condição do while é avaliada?
O corpo pode executar zero vezes?
O que é uma iteração?
Qual papel day desempenha no nosso exemplo?
Por que day++ é importante?
Como surge um loop infinito?
Por que < e <= podem produzir quantidades diferentes de iterações?
O que é um erro off-by-one?
Por que o valor inicial também importa?
Como if pode ser utilizado dentro de while?
Por que ainda não estamos construindo nosso Game Loop real?
Qual é a relação entre estado, condição e atualização?

Se consegue explicar essas respostas com suas próprias palavras, podemos continuar.

51. Git

Depois de validar:

  git status

Adicione o arquivo:

  git add CppGameEngine/main.cpp

Ajuste o caminho caso sua estrutura local seja diferente.

Commit sugerido:

  git commit -m "feat: add conditional repetition with while loop"

Esse commit representa uma nova capacidade:

nosso programa agora consegue repetir ações enquanto uma condição permanecer verdadeira.

52. Atualizando o CHANGELOG

Em [Unreleased]:

  ### Added

- Added controlled repetition using `while`.
- Added day-based simulation with loop state updates.
- Added conditional event handling inside a loop.
- Added boundary validation for loop conditions.
- Added intentional infinite-loop and off-by-one exercises.

Depois:

  git add CHANGELOG.md
git commit -m "docs: update changelog with while loop examples"

O ROADMAP técnico ainda não precisa de alteração para esse avanço isolado.

53. O que aprendemos?

Antes deste capítulo nosso programa conseguia:

  armazenar
calcular
comparar
decidir
escolher

Agora também consegue:

  repetir

Conhecemos:

  while (condition)
{
}

e aprendemos que um loop depende de elementos como:

  estado inicial
+
condição
+
ação repetida
+
atualização do estado

Também aprendemos que:

a condição é avaliada antes de cada iteração;
o bloco pode executar zero vezes;
cada repetição do corpo é uma iteração;
a variável de controle precisa evoluir quando a condição depende dela;
esquecer a atualização pode causar loop infinito;
um loop infinito pode parecer um programa travado;
< e <= mudam a fronteira da repetição;
erros off-by-one são comuns;
valores de fronteira precisam ser testados;
if e while podem trabalhar juntos;
repetição controlada será fundamental para nossos sistemas futuros.

Conclusão

Até aqui, nosso programa precisava receber cada instrução explicitamente.

Se quiséssemos cinco dias:

  std::cout << "Day 1" << std::endl;
std::cout << "Day 2" << std::endl;
std::cout << "Day 3" << std::endl;
std::cout << "Day 4" << std::endl;
std::cout << "Day 5" << std::endl;

Agora podemos representar a regra:

  int day = 1;

while (day <= TOTAL_DAYS)
{
    std::cout << "Day " << day << std::endl;

    day++;
}

A diferença é enorme.

Antes escrevíamos cada repetição.

Agora descrevemos como repetir.

Podemos visualizar:

  estado
↓
condição
↓
ação
↓
atualização
↓
condição novamente
↓
...
↓
condição falsa
↓
continuar programa

Esse padrão aparecerá em inúmeras situações:

  simulações
processamento de eventos
espera controlada
tentativas
menus
estados
recursos
NPCs
sistemas de tempo
Game Loop

Mas existe outra situação extremamente comum.

Nosso loop atual utiliza:

  int day = 1;

while (day <= TOTAL_DAYS)
{
    ...
    day++;
}

Temos:

  inicialização
condição
atualização

espalhadas em três lugares.

Para loops baseados em contadores conhecidos, C++ oferece uma estrutura que reúne essas três partes de maneira muito conveniente.

É aí que chegamos ao próximo capítulo.

Próximo capítulo

Capítulo 15 — Loops com `for`

Série: Do zero ao jogo comercial com C++ e SFML

Vamos partir exatamente deste código:

  int day = 1;

while (day <= TOTAL_DAYS)
{
    std::cout << "Day " << day << std::endl;

    day++;
}

e observar que temos:

  inicialização
↓
int day = 1

condição
↓
day <= TOTAL_DAYS

atualização
↓
day++

Quando essas três partes pertencem claramente à mesma repetição, podemos expressá-las com:

for

Chegaremos a algo parecido com:

  for (int day = 1; day <= TOTAL_DAYS; day++)
{
    std::cout << "Day " << day << std::endl;
}

Mas não vamos apenas trocar a sintaxe.

Vamos entender:

por que for existe;
como suas três partes funcionam;
quando ele comunica melhor a intenção que while;
quando while continua sendo mais adequado;
como surgem erros de limite;
como fazer contagens crescentes e decrescentes;
como variar o passo;
como testar início, fim e número de iterações;
e por que compreender while primeiro torna for muito mais fácil de entender.

Nosso programa já sabe repetir enquanto uma condição permanecer verdadeira.

No próximo capítulo aprenderemos uma forma especialmente conveniente de repetir quando inicialização, condição e atualização pertencem claramente ao mesmo contador.

Subscreve "Aeca" para receber atualizações diretamente na tua caixa de entrada

Subscreve aeca para reagir

Subscrever

Comentários

Subscreve para comentar

Ainda não há comentários. Sê o primeiro a comentar!

Nosso programa já sabe escolher. Agora ele precisa aprender a repetir ações enquanto uma condição permanecer verdadeira.

1. Começando pelo problema

2. Conhecendo while

3. Nosso primeiro while

4. Vamos desmontar o loop

5. Primeira iteração

6. Segunda iteração

7. Quando o loop termina?

8. Podemos mostrar isso explicitamente

9. Loop significa repetição controlada

10. A condição é uma expressão booleana

11. while testa antes de executar

12. Um while pode não executar nenhuma vez

13. O que é uma iteração?

14. O contador

15. A atualização é essencial

16. Criamos um loop infinito

17. Loop infinito não significa necessariamente "travamento"

18. Como interromper durante o desenvolvimento

19. Método para investigar loops infinitos

20. Restaurando a atualização

21. A atualização não precisa ser ++

22. O estado pode mudar de outras formas

23. Um vislumbre do futuro

24. while e estado trabalham juntos

25. Outro exemplo contextual: recursos produzidos

26. A posição da atualização altera o resultado

27. Erros de limite começam a aparecer

28. < e <= mudam a fronteira

29. Off-by-one errors

30. Teste as bordas do loop

31. O valor inicial também importa

32. Um loop é a combinação de várias decisões

33. if dentro de while

34. Não confunda repetição com duplicação de lógica

35. Ainda não precisamos de funções

36. Ainda não precisamos de SFML

37. Microdesafio — dias

38. Uma possível solução

39. Microdesafio — energia

40. Microdesafio — evento no terceiro dia

41. Erro proposital — loop infinito

42. Erro proposital — condição falsa desde o início

43. Erro proposital — um dia a menos

44. Código final do capítulo

45. O que esse código representa?

46. A arquitetura continua mínima

47. Validando a implementação

48. Cenários de validação

49. Cenário especial: limite zero

50. Checklist de compreensão

51. Git

52. Atualizando o CHANGELOG

53. O que aprendemos?

Conclusão

Capítulo 15 — Loops com for

Comentários

2. Conhecendo `while`

3. Nosso primeiro `while`

11. `while` testa antes de executar

12. Um `while` pode não executar nenhuma vez

21. A atualização não precisa ser `++`

24. `while` e estado trabalham juntos

28. `<` e `<=` mudam a fronteira

33. `if` dentro de `while`

Capítulo 15 — Loops com `for`