Bem-vindo ao sétimo capítulo da Especialização em Engenharia de Sistemas com Linguagem C (C17/C23)! ⚡

Enquanto as estruturas while e do-while são ideais para laços com número indeterminado de repetições (orientados a eventos ou sentinelas), o laço for é a estrutura perfeita para repetições determinísticas, onde os limites inicial e final são previamente conhecidos. Neste capítulo, você dominará o for, laços aninhados multidimensionais, instruções de salto break/continue e compreenderá o impacto da Complexidade Assintótica Big-O ($O(N)$ vs $O(N^2)$) no desempenho de sistemas.

Laço for, break/continue e Complexidade Big-O em C

🗺️ Mapa Conceitual do Capítulo

graph TD
    A["Estrutura for & Complexidade"] --> B["1. Anatomia do for"]
    A --> C["2. Saltos de Controle"]
    A --> D["3. Laços Aninhados (2D/3D)"]
    A --> E["4. Complexidade Big-O"]

    B --> B1["for (init; cond; step) | Escopo local ISO C99 | for (;;)"]
    C --> C1["break (saída imediata) vs continue (salta para o próximo passo)"]
    D --> D1["Iteração linha x coluna (Matrizes e Grids)"]
    E --> E1["Tempo Linear O(N) vs Tempo Quadrático O(N²)"]

🔄 1. A Anatomia do Laço for

A estrutura for reúne os três passos fundamentais de um laço em uma única linha compacta e legível:

for (/* 1. Inicialização */; /* 2. Condição de Continuidade */; /* 3. Atualização/Passo */) {
    // Corpo executável do laço
}

sequenceDiagram
    autonumber
    participant CPU as Execução da CPU
    participant Init as 1. Inicialização (1 vez só)
    participant Cond as 2. Condição de Teste
    participant Body as Corpo do Laço
    participant Step as 3. Atualização (Passo)

    CPU->>Init: Executa 'int i = 0'
    loop Cada Iteração
        CPU->>Cond: Testa 'i < N'
        alt Verdadeiro
            CPU->>Body: Executa comandos
            CPU->>Step: Executa 'i++'
        else Falso
            CPU->>CPU: Sai do laço
        end
    end

Escopo Local de Variáveis de Controle (Padrão ISO C99+)

No C moderno, a variável de controle pode ser declarada diretamente dentro do cabeçalho do for. Sua visibilidade e ciclo de vida ficam restritos exclusivamente ao corpo do laço:

for (int i = 0; i < 10; i++) {
    printf("%d ", i);
}
// Aqui fora, 'i' já deixou de existir na memória Stack!

⚡ 2. Instruções de Salto: break vs continue

Comando Ação no Laço de Repetição Exemplo Típico de Uso
break; Interrompe e finaliza o laço imediatamente, saltando para a primeira linha fora das chaves. Busca de elementos: interrompe assim que o dado for encontrado.
continue; Ignora o restante do corpo na volta atual e salta imediatamente para a cláusula de atualização. Filtragem: ignora itens nulos, pares ou inválidos e passa para o próximo. 
// Exemplo: Imprimir números ímpares de 1 a 10, parando se encontrar o 7
for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue; // Pula os números pares
    }
    if (i == 7) {
        printf("[Atingiu 7: Interrompendo!] ");
        break;    // Encerra o laço
    }
    printf("%d ", i);
}
// Saída: 1 3 5 [Atingiu 7: Interrompendo!]

🔲 3. Laços Aninhados (Nested Loops)

Um laço aninhado ocorre quando um for é colocado dentro de outro for. É o mecanismo canônico para percorrer estruturas bidimensionais (como matrizes, imagens em pixels e tabelas):

// Exemplo: Gerador de Tabuada 2D (Linhas x Colunas)
for (int lin = 1; lin <= 3; lin++) {
    for (int col = 1; col <= 3; col++) {
        printf("[%d x %d = %d]\t", lin, col, lin * col);
    }
    printf("\n"); // Nova linha ao final de cada linha da tabela
}

📈 4. Noções de Complexidade Assintótica Big-O ($O(N)$ vs $O(N^2)$)

Na Engenharia de Sistemas, medir como o tempo de processamento de um algoritmo cresce em função do volume de dados de entrada ($N$) é essencial:

Complexidade Big-O em Laços:
--------------------------------------------------------------------------------
1. Laço Único Simples       -> O(N)   (Linear)
   for (int i = 0; i < N; i++) { ... }
   - Se N = 1.000       => 1.000 iterações (0.001 ms)
   - Se N = 1.000.000   => 1.000.000 iterações (1 ms)

2. Dois Laços Aninhados     -> O(N²)  (Quadrático)
   for (int i = 0; i < N; i++) {
       for (int j = 0; j < N; j++) { ... }
   }
   - Se N = 1.000       => 1.000.000 iterações (1 ms)
   - Se N = 100.000     => 10.000.000.000 iterações (10 segundos na CPU!)
--------------------------------------------------------------------------------

[!CAUTION] Alerta de Engenharia de Sistemas (CERT C): Nunca utilize variáveis de ponto flutuante (float, double) como variáveis de controle de um for (ex: for (float f = 0.0f; f != 1.0f; f += 0.1f)). Devido a imprecisões de arredondamento da norma IEEE 754, f pode nunca ser exatamente igual a 1.0f, transformando o laço em um loop infinito fatal!

🔍 5. Diagnóstico & Resolução de Problemas (Troubleshooting)

Sintoma Observado Causa Provável Como Resolver
O laço for executa apenas uma vez e não itera Ponto e vírgula indevido após o parêntese do for (ex: for (int i=0; i<10; i++); { ... }). Remova o ponto e vírgula ; no final da declaração do for.
A variável de controle não é reconhecida fora do laço A variável foi declarada dentro do cabeçalho for (int i = 0; ...) e possui escopo local. Se precisar do valor final de i fora do laço, declare int i; antes do for.
O continue dentro de um while gera loop infinito O comando continue pulou a linha do i++ no final do corpo do while. No for, o continue salta direto para a cláusula de passo com segurança; no while, a atualização deve ser feita antes do continue.

🏆 6. Desafio Prático de Consolidação

Enunciado do Desafio: Desenvolva um programa em C chamado renderizador_ascii.c que gere um padrão gráfico bidimensional em console:

  1. Solicite ao usuário o tamanho do lado $N$ de uma matriz quadrada (de 3 a 20).
  2. Utilize dois laços for aninhados ($O(N^2)$) para desenhar:
    • Caracteres '#' nas bordas externas do quadrado.
    • Caracteres 'X' na diagonal principal (onde linha == coluna).
    • Caracteres 'X' na diagonal secundária (onde linha + coluna == N - 1).
    • Caracteres '.' (ponto) nos demais espaços internos.
  3. Meça e exiba a quantidade total de operações atômicas executadas pela CPU ($N \times N$).
🔍 Ver Solução Comentada do Desafio 
#include <stdio.h>
#include <stdbool.h>

bool ehPrimo(int n) {
    if (n < 2) return false;
    if (n == 2) return true;
    if (n % 2 == 0) return false;
    for (int d = 3; d * d <= n; d += 2) {
        if (n % d == 0) return false;
    }
    return true;
}

int main(void) {
    int limite = 50;
    int totalPrimos = 0;

    printf("Numeros primos entre 1 e %d:\n", limite);
    for (int i = 1; i <= limite; i++) {
        if (ehPrimo(i)) {
            printf("%d ", i);
            totalPrimos++;
        }
    }
    printf("\nTotal de primos encontrados: %d\n", totalPrimos);

    return 0;
}

🧭 Navegação Rápida

| 📖 Teoria | 📊 Slides | 🧠 Quiz | 💻 Exemplos | 🧩 Exercícios | | :— | :— | :— | :— | :— | | Ler Teoria | Ver Slides | Fazer Quiz | Ver Exemplos | Praticar Exercícios |

🧭 Navegação do Capítulo: ⬅️ Capítulo Anterior · 📚 Sumário do Módulo · ➡️ Próximo Capítulo