Em C, existem várias estruturas de controle de repetição que permitem executar um bloco de código múltiplas vezes. As mais comuns são while, for e do-while. Cada uma possui uma sintaxe e um fluxo de execução ligeiramente diferentes, adequados para cenários distintos.

1. Estrutura while

A estrutura while é utilizada quando se deseja repetir um bloco de código enquanto uma determinada condição for verdadeira.

1.1. Sintaxe e Uso

A sintaxe básica é:

while (condicao) {
    // Bloco de código a ser executado
}

O programa verifica a condicao. Se for verdadeira (ou diferente de zero), o bloco de código dentro das chaves é executado. Após a execução, a condição é verificada novamente. Este processo se repete até que a condicao se torne falsa (zero).

1.2. Controle de Saída com break

A instrução break pode ser usada para sair prematuramente do loop while, mesmo que a condição principal ainda seja verdadeira.

while (condicao) {
    // ... código ...
    if (alguma_condicao_especifica) {
        break; // Sai permanentemente do loop
    }
    // ... mais código ...
}

O exemplo a seguir demonstra como usar while e break para verificar se um número é primo:

#include <stdio.h>

int main() {
    int numero;
    scanf("%d", &numero);
    int divisor = 2;
    int eh_primo = 1; // Assume que é primo inicialmente

    if (numero < 2) {
        eh_primo = 0; // Números menores que 2 não são primos
    } else {
        while (divisor < numero) {
            if (numero % divisor == 0) {
                eh_primo = 0; // Encontrou um divisor, não é primo
                break;       // Sai do loop, não precisa testar mais divisores
            }
            divisor++;
        }
    }

    if (eh_primo) {
        printf("O numero %d eh primo.\n", numero);
    } else {
        printf("O numero %d nao eh primo.\n", numero);
    }
    return 0;
}

1.3. Controle de Pulo com continue

A instrução continue pula o restante do código dentro da iteração atual do loop e passa para a próxima verificação da condição.

while (condicao) {
    // ... código ...
    if (alguma_condicao_especifica) {
        continue; // Pula para a próxima verificação da condição
    }
    // ... código que será pulado se continue for executado ...
}

Importante: A instrução que atualiza a variável de controle do loop (como divisor++ no exemplo de número primo) não deve ser colocada após um continue que possa ser executado indefinidamente, pois isso levaria a um loop infinito.

Exemplo de verificação de número primo usando continue:

#include <stdio.h>

int main() {
    int numero;
    scanf("%d", &numero);
    int divisor = 2;
    int eh_primo = 1;

    if (numero < 2) {
        eh_primo = 0;
    } else {
        while (divisor < numero) {
            if (numero % divisor != 0) {
                divisor++;
                continue; // Pula o resto desta iteração e vai para a próxima verificação
            }
            // Se chegou aqui, numero % divisor == 0
            eh_primo = 0;
            break; // Sai do loop, pois encontrou um divisor
        }
    }

    if (eh_primo) {
        printf("O numero %d eh primo.\n", numero);
    } else {
        printf("O numero %d nao eh primo.\n", numero);
    }
    return 0;
}

2. Estrutura for

A estrutura for é frequentemente usada quando o número de iterações é conhecido de antemão ou quando a inicialização, a condição e a atualização da variável de controle podem ser definidas em um único local.

2.1. Sintaxe e Uso

A sintaxe básica é:

for (inicializacao; condicao; atualizacao) {
    // Bloco de código a ser executado
}

O fluxo de execução é:

1. inicializacao: Executada uma única vez no início.
2. condicao: Verificada antes de cada iteração. Se for verdadeira, o bloco de código é executado.
3. Bloco de código: Executado se a condicao for verdadeira.
4. atualizacao: Executada após cada execução do bloco de código.

Este ciclo se repete até que a condicao se torne falsa.

A estrutura for é vantajosa por agrupar a inicialização, condição e atualização, o que melhora a legibilidade e a manutenção do código em comparação com while, onde esses elementos podem estar dispersos.

2.2. Controle de Saída com break

Assim como em while, break em um loop for encerra permanentemente o loop.

#include <stdio.h>

int main() {
    for (int contador = 1; contador <= 10; contador++) {
        if (contador == 5) {
            break; // Sai do loop quando contador for 5
        }
        printf("%d ", contador);
    }
    // Saída: 1 2 3 4
    printf("\n");
    return 0;
}

2.3. Controle de Pulo com continue

continue em um loop for pula o restante do código da iteração atual e executa a parte de atualizacao, seguido pela verificação da condicao.

#include <stdio.h>

int main() {
    for (int contador = 1; contador <= 10; contador++) {
        if (contador == 5) {
            continue; // Pula o printf quando contador for 5
        }
        printf("%d ", contador);
    }
    // Saída: 1 2 3 4 6 7 8 9 10
    printf("\n");
    return 0;
}

A vantagem do for é que a instrução de atualização está na própria definição do loop, minimizando o risco de criar loops infinitos acidentalmente com continue.

3. Estrutura do-while

A estrutura do-while é semelhante à while, com a principal diferença sendo que o bloco de código é executado pelo menos uma vez antes que a condição seja verificada.

3.1. Sintaxe e Uso

A sintaxe básica é:

do {
    // Bloco de código a ser executado
} while (condicao);

O bloco de código dentro das chaves é executado primeiro. Em seguida, a condicao é verificada. Se for verdadeira, o bloco é executado novamente. O loop continua até que a condicao se torne falsa.

3.2. Controle com break e continue

As instruções break e continue funcionam de maneira idêntica à sua implementação em loops while e for.

Exemplo com break:

#include <stdio.h>

int main() {
    int contador = 1;
    do {
        if (contador == 5) {
            break; // Sai do loop
        }
        printf("%d ", contador);
        contador++;
    } while (contador <= 10);
    // Saída: 1 2 3 4
    printf("\n");
    return 0;
}

Exemplo com continue:

#include <stdio.h>

int main() {
    int contador = 1;
    do {
        if (contador == 5) {
            contador++; // Importante incrementar antes do continue
            continue;  // Pula o printf
        }
        printf("%d ", contador);
        contador++;
    } while (contador <= 10);
    // Saída: 1 2 3 4 6 7 8 9 10
    printf("\n");
    return 0;
}

4. Instrução goto

A instrução goto permite transferir o controle de execução para outro ponto dentro da mesma função, marcado por um rótulo (label).

4.1. Uso da Instrução goto

goto rotulo;
// ... outro código ...
rotulo:
// ... código a ser executado após o goto ...

Embora o goto possa ser útil para sair de múltiplos níveis de loops aninhados de forma rápida, seu uso é geralmente desencorajado na programação moderna, pois pode tornar o código mais difícil de ler, depurar e manter, prejudicando a estrutura do fluxo de controle.