Laço for em C | Como Escrever Iterações em C

Por que precisamos de laços? — A dor da repetição

E se laços não existissem? Vamos tentar "imprimir de 1 a 5" sem um, e ver como programar ficaria tedioso.

❌ Sem laços

#include <stdio.h>

int main(void) {
    printf("1\n");
    printf("2\n");
    printf("3\n");
    printf("4\n");
    printf("5\n");
    return 0;
}

Cinco é quase tolerável — mas e se você tivesse que imprimir de 1 a 100?

Imagine isto: lhe pedem para imprimir de 1 a 100. Você realmente escreveria printf("1\n"); printf("2\n"); ... printf("100\n"); para 100 linhas? E se a especificação mudasse para "apenas múltiplos de 3", você teria que reescrever tudo.

✅ Com um laço

#include <stdio.h>

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

Apenas três linhas! Quer ir até 100? Mude 5 para 100. Até 10.000 iterações cabem na mesma quantidade de código.

Sinta o poder dos laços com este slider

Arraste para mudar a contagem de iterações e veja quantas linhas você precisaria sem um laço.

Iterações N = 5

❌ Sem laço

5 linhas

Um printf por iteração, N vezes

✅ Com laço

3 linhas

Mesmo código, qualquer que seja N

Piora quando a lógica muda

Calcular "a soma de 1 a 10" sem um laço é igualmente doloroso.

// Sem laco: somar manualmente cada numero
int sum = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10;

// Com laco
int sum = 0;
for (int i = 1; i <= 10; i++) sum += i;

A essência dos laços: "repetir o mesmo padrão com um valor ligeiramente diferente a cada vez." É um dos conceitos mais importantes em programação — você vai vê-lo em quase todo programa que escrever.

Piora ainda mais: se a contagem de iterações depende de entrada do usuário (ex.: "soma de 1 a N onde N é digitado em tempo de execução"), você não consegue escrever sem um laço. Simplesmente não se sabe quantos printfs escrever até o programa rodar.

Laço for — um número fixo de iterações

for (int i = 0; i < 5; i++) {
  printf("i = %d\n", i);
}

🔍 O (...) de um laço for se divide em três partes

Em for ( A ; B ; C ), cada uma das três seções separadas por ponto e vírgula tem seu próprio papel.

      for (A: init ; B: condição ; C: update) { ... }
    

A: init (roda uma vez no início)

Roda uma vez, antes do laço começar. Geralmente declara o contador e define seu valor inicial.
Exemplo: int i = 0

B: condição (verificada antes de cada iteração)

Verificada no topo de cada iteração. Se verdadeira, o corpo roda; se falsa, o laço termina.
Exemplo: i < 5

C: update (roda ao fim de cada iteração)

Roda depois do corpo a cada vez, geralmente para avançar o contador (incremento ou decremento).
Exemplo: i++

📋 Rastreamento da ordem de execução (for (int i = 0; i < 3; i++) printf("%d ", i);)

      ① A: i = 0 (roda uma vez)

      ② B: i < 3 ? → verdadeiro → corpo: printf("0 ") → C: i++ → i=1

      ③ B: i < 3 ? → verdadeiro → corpo: printf("1 ") → C: i++ → i=2

      ④ B: i < 3 ? → verdadeiro → corpo: printf("2 ") → C: i++ → i=3

      ⑤ B: i < 3 ? → falso → laço termina (nem corpo nem C rodam)

      Saída: 0 1 2

💡 Qualquer uma das três partes pode ser omitida (mas o significado muda)

Omitir A: use quando a inicialização não for necessária — por exemplo, quando int i = 0; é declarado fora do for.
Omitir B: uma condição ausente é tratada como sempre verdadeira → laço infinito. Não vai parar sem um break.
Omitir C: atualize o contador você mesmo no corpo — por exemplo, i += 1 ao fim do bloco.
Omitir os três: for (;;) é o idioma clássico de laço infinito (equivalente a while (1)).

🎨 Cinco padrões comuns

① 0 a N-1 (mais comum)

for (int i = 0; i < N; i++) { ... }

O laço padrão de índice de array: 0, 1, …, N-1

② 1 a N

for (int i = 1; i <= N; i++) { ... }

Um laço estilo matemático "conte a partir de 1": 1, 2, …, N

③ Contagem regressiva (i--)

for (int i = N; i >= 0; i--) { ... }

Conta para baixo N, N-1, …, 1, 0 — útil para processar coisas ao contrário.

④ Pular (i += 2)

for (int i = 0; i < N; i += 2) { ... }

Somente números pares — passo de dois: 0, 2, 4, …

⑤ Laço infinito (omitir B ou for (;;))

for (;;) {
  ...
  if (condicao_saida) break;
}

Coloca a condição de saída dentro do corpo via break — comum para laços de menu e laços de eventos.

Visualizador de contagem de iterações

N = 5

i atual

—

Iterações

Execução passo a passo — laço for

for_demo.c

Estado das variáveis

Nome	Tipo	Valor

Saída padrão

break e continue — controle de laço

break

Sai do laço imediatamente. Todas as iterações restantes são puladas.

for (int i=0; i<10; i++) {
    if (i == 5) break;
    printf("%d ", i);
}
// Saida: 0 1 2 3 4

continue

Pula o resto da iteração atual e passa para a próxima. O laço em si continua.

for (int i=0; i<5; i++) {
    if (i == 2) continue;
    printf("%d ", i);
}
// Saida: 0 1 3 4 (pula 2)

Atenção: break e continue afetam apenas o laço mais interno. Um break dentro de um laço aninhado não sai do externo.

🔍 continue a fundo — comportamento, enganos, legibilidade

continue significa "pule o resto desta iteração e vá para a próxima." Diferente do break, o laço não sai. Vamos rastrear passo a passo.

📋 Rastreamento de execução com continue

for (int i = 0; i < 5; i++) {
    if (i == 2) continue;    // ← quando i==2, pula o resto
    printf("%d ", i);     // nao e alcancado apos continue
}

Iteração 1 (i=0): i==2 falso → printf → imprime 0 → i++ faz i=1
Iteração 2 (i=1): i==2 falso → printf → imprime 1 → i++ faz i=2
Iteração 3 (i=2): i==2 verdadeiro → continue → printf pulado → i++ ainda faz i=3 (ponto-chave)
Iteração 4 (i=3): i==2 falso → printf → imprime 3
Iteração 5 (i=4): i==2 falso → printf → imprime 4 → i=5 encerra o laço

💡 Ponto-chave: depois do continue, a cláusula de update do for i++ ainda roda. É por isso que i=2 é pulado mas i=3 vem em seguida.

🔴 Engano ①: "continue é meio que como break, né?"

São opostos. Trocar um pelo outro muda o comportamento completamente.

	break	continue
Laço inteiro	Sai (terminou)	Continua (próxima iteração)
Resto desta iteração	Pulado	Pulado
Update do for `i++`	Não roda	Roda
Quando usar	"Terminei de procurar"	"pule só este elemento"

🔴 Engano ②: continue dentro de um while pode causar laço infinito

Num laço for, o update do contador fica no cabeçalho — sempre roda. Num while você atualiza o contador você mesmo dentro do corpo, e continue pode pular isso. É uma armadilha clássica de laço infinito.

int i = 0;
while (i < 5) {
    if (i == 2) continue;  // ❌ nunca alcanca i++ → preso em i=2 pra sempre
    printf("%d ", i);
    i++;
}

Correção: incremente o contador antes do continue:

if (i == 2) { i++; continue; }  // ✅ seguro

💡 continue vs. envolver num if — um compromisso de legibilidade

"Pular certos itens" pode ser escrito com continue ou com um if. Qual lê melhor depende da situação.

✅ continue vence: padrão de pulo antecipado

for (int i=0; i<n; i++) {
    if (arr[i] < 0) continue;  // pula negativos
    if (arr[i] == 0) continue; // pula zeros tambem

    // processamento principal longo para positivos...
    process(arr[i]);
    total += arr[i] * 2;
}

Filtrar casos indesejados logo no começo mantém o bloco principal plano e legível.

⚠️ A mesma coisa com if fica aninhada

for (int i=0; i<n; i++) {
    if (arr[i] > 0) {  // inverter e envolver
        process(arr[i]);
        total += arr[i] * 2;
    }
}

Uma condição simples é OK. Várias condições de pulo tornam o aninhamento profundo.

Regra prática:
• Um pulo simples + corpo curto → use if
• Múltiplos pulos + corpo longo → use continue (estilo guard-clause)
É a mesma ideia de um return antecipado em funções — veja Instrução if.

Experimente — laços

my_loop.c

Saída

Clique em "Executar" para rodar...

💡 Experimente estas ideias também

Imprima só números pares, ou faça contagem regressiva (10, 9, …, 1)
Use um for aninhado para imprimir uma tabuada
Decida onde break e continue fazem sentido
Converta para do-while e veja o comportamento "garante uma vez"

Teste de Revisão

Teste seu entendimento desta aula!

Q1. Quantas vezes `for (int i=0; i<5; i++)` executa?

4 vezes

5 vezes

6 vezes

i assume os cinco valores 0, 1, 2, 3, 4, então o corpo roda 5 vezes.

Q2. Quantas vezes `for (int i=10; i>0; i--)` executa?

9 vezes

10 vezes

11 vezes

i assume os dez valores 10, 9, 8, …, 1, então o corpo roda 10 vezes. A condição i > 0 significa que o corpo nunca roda quando i=0.

Q3. O que `for (;;) { ... }` faz?

Roda zero vezes

Laço infinito

Erro de compilação

Quando as três partes (init / condição / update) são omitidas, a condição ausente é tratada como sempre verdadeira, então o laço roda para sempre. Use break ou return para sair.

Q4. O que este código imprime?

for (int i = 0; i < 5; i++) {
    if (i == 3) continue;
    printf("%d ", i);
}

0 1 2 3 4

0 1 2 4

0 1 2

continue pula o resto da iteração atual e avança. O printf só é pulado quando i=3, então a saída é 0 1 2 4.
Com break, o laço sairia totalmente naquele ponto, dando 0 1 2 — não confunda os dois.

Aula 11: Laço for

Por que precisamos de laços? — A dor da repetição

❌ Sem laços

✅ Com um laço

Sinta o poder dos laços com este slider

Piora quando a lógica muda

Laço for — um número fixo de iterações

🔍 O (...) de um laço for se divide em três partes

🎨 Cinco padrões comuns

Visualizador de contagem de iterações

Execução passo a passo — laço for

Estado das variáveis

Saída padrão

break e continue — controle de laço

🔍 continue a fundo — comportamento, enganos, legibilidade

Experimente — laços

Aulas Relacionadas

Teste de Revisão

Q1. Quantas vezes `for (int i=0; i<5; i++)` executa?

Q2. Quantas vezes `for (int i=10; i>0; i--)` executa?

Q3. O que `for (;;) { ... }` faz?

Q4. O que este código imprime?

Por que precisamos de laços? — A dor da repetição

❌ Sem laços

✅ Com um laço

Sinta o poder dos laços com este slider

Piora quando a lógica muda

Laço for — um número fixo de iterações

🔍 O (...) de um laço for se divide em três partes

🎨 Cinco padrões comuns

Visualizador de contagem de iterações

Execução passo a passo — laço for

Estado das variáveis

Saída padrão

break e continue — controle de laço

🔍 continue a fundo — comportamento, enganos, legibilidade

Experimente — laços

Aulas Relacionadas

Teste de Revisão

Q1. Quantas vezes for (int i=0; i<5; i++) executa?

Q2. Quantas vezes for (int i=10; i>0; i--) executa?

Q3. O que for (;;) { ... } faz?

Q4. O que este código imprime?

Q1. Quantas vezes `for (int i=0; i<5; i++)` executa?

Q2. Quantas vezes `for (int i=10; i>0; i--)` executa?

Q3. O que `for (;;) { ... }` faz?