Loops Condicionais em C

Introdução

Neste laboratório, você aprenderá como implementar loops condicionais na programação C. Começará compreendendo os fundamentos dos loops while, explorando em seguida o uso das diretivas break e continue para controlar a execução do loop. Adicionalmente, aprenderá como filtrar elementos de um array usando instruções condicionais e otimizar a eficiência do loop com várias diretivas. Ao final deste laboratório, você terá uma sólida compreensão dos loops condicionais e suas aplicações práticas na programação C.

Entenda os Loops While

Nesta etapa, você aprenderá os fundamentos dos loops while na programação C. Os loops while são estruturas de controle poderosas que permitem repetir um bloco de código enquanto uma condição específica permanecer verdadeira.

Vamos criar um programa C simples para demonstrar a sintaxe básica de um loop while. Abra o editor VSCode e crie um novo arquivo chamado while_loop_example.c no diretório ~/project.

cd ~/project
touch while_loop_example.c

#include <stdio.h>

int main() {
    int count = 1;

    while (count <= 5) {
        printf("Current count: %d\n", count);
        count++;
    }

    return 0;
}

Vamos analisar o código:

• int count = 1; inicializa uma variável contadora
• while (count <= 5) cria um loop que continua enquanto count for menor ou igual a 5
• printf() exibe o valor atual de count
• count++ incrementa o contador em cada iteração

Compile e execute o programa:

gcc while_loop_example.c -o while_loop_example
./while_loop_example

Exemplo de saída:

Current count: 1
Current count: 2
Current count: 3
Current count: 4
Current count: 5

Aqui está outro exemplo que demonstra um loop while com entrada do usuário:

#include <stdio.h>

int main() {
    int number;

    printf("Enter numbers (enter 0 to stop):\n");

    number = 1;  // Initialize to non-zero value
    while (number != 0) {
        printf("Enter a number: ");
        scanf("%d", &number);

        if (number != 0) {
            printf("You entered: %d\n", number);
        }
    }

    printf("Loop ended. Goodbye!\n");

    return 0;
}

Este exemplo mostra como os loops while podem ser usados para entrada interativa, continuando até que uma condição específica (inserir 0) seja atendida.

Aplique a Diretiva Break em Loops While

Nesta etapa, você aprenderá sobre a diretiva break na programação C, que permite sair de um loop prematuramente quando uma condição específica é atendida. A instrução break fornece uma maneira de terminar imediatamente o loop atual e continuar a execução com a próxima instrução após o loop.

Vamos criar um novo arquivo chamado break_loop_example.c no diretório ~/project para demonstrar o uso de break:

cd ~/project
touch break_loop_example.c

#include <stdio.h>

int main() {
    int number;

    printf("Enter numbers to find the first multiple of 10:\n");

    while (1) {  // Infinite loop
        printf("Enter a number: ");
        scanf("%d", &number);

        if (number % 10 == 0) {
            printf("Found a multiple of 10: %d\n", number);
            break;  // Exit the loop when a multiple of 10 is found
        }

        printf("Not a multiple of 10. Try again.\n");
    }

    printf("Loop terminated after finding a multiple of 10.\n");

    return 0;
}

Vamos analisar o código:

• while (1) cria um loop infinito que continuará até que uma instrução break seja encontrada
• Quando o usuário insere um número divisível por 10, a instrução break sai imediatamente do loop
• Se o número não for divisível por 10, o loop continua solicitando a entrada

Aqui está outro exemplo que demonstra break em um cenário mais complexo:

#include <stdio.h>

int main() {
    int sum = 0;
    int count = 0;
    int input;

    printf("Enter numbers (enter a negative number to stop):\n");

    while (1) {
        printf("Enter a number: ");
        scanf("%d", &input);

        if (input < 0) {
            break;  // Exit the loop if a negative number is entered
        }

        sum += input;
        count++;
    }

    if (count > 0) {
        printf("Average of entered numbers: %.2f\n", (float)sum / count);
    } else {
        printf("No numbers were entered.\n");
    }

    return 0;
}

Este exemplo mostra como break pode ser usado para:

• Parar de coletar entrada quando uma condição específica é atendida
• Calcular a média dos números inseridos
• Fornecer flexibilidade na terminação do loop

Compile e execute os programas para ver como a diretiva break funciona:

gcc break_loop_example.c -o break_loop_example
./break_loop_example

Utilize a Diretiva Continue em Loops While

Nesta etapa, você aprenderá sobre a diretiva continue na programação C, que permite pular a iteração atual de um loop e passar para a próxima iteração. A instrução continue fornece uma maneira de executar ou pular seletivamente partes de um loop com base em condições específicas.

Vamos criar um novo arquivo chamado continue_loop_example.c no diretório ~/project para demonstrar o uso de continue:

cd ~/project
touch continue_loop_example.c

#include <stdio.h>

int main() {
    int number;
    int sum_even = 0;
    int count_even = 0;

    printf("Enter 10 numbers to calculate the sum and count of even numbers:\n");

    int i = 0;
    while (i < 10) {
        printf("Enter number %d: ", i + 1);
        scanf("%d", &number);

        // Skip odd numbers
        if (number % 2 != 0) {
            printf("Skipping odd number: %d\n", number);
            continue;  // Move to the next iteration
        }

        sum_even += number;
        count_even++;

        i++;
    }

    if (count_even > 0) {
        printf("Sum of even numbers: %d\n", sum_even);
        printf("Count of even numbers: %d\n", count_even);
        printf("Average of even numbers: %.2f\n", (float)sum_even / count_even);
    } else {
        printf("No even numbers were entered.\n");
    }

    return 0;
}

Vamos analisar o código:

• O programa pede ao usuário para inserir 10 números
• if (number % 2 != 0) verifica se o número é ímpar
• continue pula o restante da iteração atual para números ímpares
• Apenas números pares são adicionados à soma e contados

Aqui está outro exemplo que demonstra continue com condições mais complexas:

#include <stdio.h>

int main() {
    int number;
    int positive_count = 0;
    int negative_count = 0;

    printf("Enter numbers (enter 0 to stop):\n");

    while (1) {
        printf("Enter a number: ");
        scanf("%d", &number);

        // Exit the loop if 0 is entered
        if (number == 0) {
            break;
        }

        // Skip zero
        if (number == 0) {
            continue;
        }

        // Count positive and negative numbers
        if (number > 0) {
            positive_count++;
        } else {
            negative_count++;
        }
    }

    printf("Positive numbers count: %d\n", positive_count);
    printf("Negative numbers count: %d\n", negative_count);

    return 0;
}

Este exemplo mostra como continue pode ser usado para:

• Pular valores específicos
• Processar seletivamente números com base em condições
• Fornecer um controle de loop mais flexível

Compile e execute os programas para ver como a diretiva continue funciona:

gcc continue_loop_example.c -o continue_loop_example
./continue_loop_example

Filtrar Elementos de Array com Declarações Condicionais

Nesta etapa, você aprenderá como filtrar elementos de array usando declarações condicionais e loops na programação C. A filtragem permite selecionar elementos específicos de um array com base em certas condições.

Vamos criar um novo arquivo chamado array_filtering.c no diretório ~/project para demonstrar a filtragem de elementos de array:

cd ~/project
touch array_filtering.c

#include <stdio.h>

#define MAX_SIZE 10

int main() {
    int numbers[MAX_SIZE];
    int filtered_even[MAX_SIZE];
    int filtered_count = 0;

    // Input array elements
    printf("Enter %d numbers:\n", MAX_SIZE);
    for (int i = 0; i < MAX_SIZE; i++) {
        printf("Enter number %d: ", i + 1);
        scanf("%d", &numbers[i]);
    }

    // Filter even numbers
    printf("\nFiltered Even Numbers:\n");
    for (int i = 0; i < MAX_SIZE; i++) {
        if (numbers[i] % 2 == 0) {
            filtered_even[filtered_count] = numbers[i];
            filtered_count++;
            printf("%d ", numbers[i]);
        }
    }

    printf("\n\nTotal even numbers: %d\n", filtered_count);

    return 0;
}

Vamos analisar o processo de filtragem:

• Criamos dois arrays: numbers para armazenar a entrada e filtered_even para armazenar os elementos filtrados
• O primeiro loop lê 10 números do usuário
• O segundo loop usa uma declaração condicional para filtrar números pares
• if (numbers[i] % 2 == 0) verifica se um número é par
• Os elementos correspondentes são armazenados no array filtered_even

Aqui está um exemplo mais complexo com múltiplas condições de filtragem:

#include <stdio.h>

#define MAX_SIZE 10

int main() {
    int numbers[MAX_SIZE];
    int prime_numbers[MAX_SIZE];
    int prime_count = 0;

    // Input array elements
    printf("Enter %d numbers:\n", MAX_SIZE);
    for (int i = 0; i < MAX_SIZE; i++) {
        printf("Enter number %d: ", i + 1);
        scanf("%d", &numbers[i]);
    }

    // Filter prime numbers
    printf("\nFiltered Prime Numbers:\n");
    for (int i = 0; i < MAX_SIZE; i++) {
        // Skip numbers less than 2
        if (numbers[i] < 2) continue;

        int is_prime = 1;
        for (int j = 2; j * j <= numbers[i]; j++) {
            if (numbers[i] % j == 0) {
                is_prime = 0;
                break;
            }
        }

        // Add prime numbers to filtered array
        if (is_prime) {
            prime_numbers[prime_count] = numbers[i];
            prime_count++;
            printf("%d ", numbers[i]);
        }
    }

    printf("\n\nTotal prime numbers: %d\n", prime_count);

    return 0;
}

Este exemplo demonstra:

• Filtragem de números primos de um array de entrada
• Loops aninhados para verificar a primalidade
• Armazenamento de elementos filtrados em um array separado

Compile e execute os programas:

gcc array_filtering.c -o array_filtering
./array_filtering

Exemplo de entrada e saída:

Enter 10 numbers:
Enter number 1: 5
Enter number 2: 12
Enter number 3: 7
Enter number 4: 15
...

Filtered Prime Numbers:
5 7

Total prime numbers: 2

Otimizar a Eficiência de Loops com Diretivas

Nesta etapa, você aprenderá técnicas para otimizar a eficiência de loops na programação C usando várias diretivas e estratégias. Exploraremos diferentes abordagens para melhorar o desempenho e a legibilidade dos loops.

Vamos criar um arquivo chamado loop_optimization.c no diretório ~/project para demonstrar técnicas de otimização:

cd ~/project
touch loop_optimization.c

#include <stdio.h>
#include <time.h>

#define ARRAY_SIZE 10000

// Function to calculate sum using traditional loop
int traditional_sum(int arr[], int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return sum;
}

// Function to calculate sum using optimized loop
int optimized_sum(int arr[], int size) {
    int sum1 = 0, sum2 = 0, sum3 = 0, sum4 = 0;

    // Loop unrolling technique
    int i;
    for (i = 0; i + 4 < size; i += 4) {
        sum1 += arr[i];
        sum2 += arr[i + 1];
        sum3 += arr[i + 2];
        sum4 += arr[i + 3];
    }

    // Handle remaining elements
    for (; i < size; i++) {
        sum1 += arr[i];
    }

    return sum1 + sum2 + sum3 + sum4;
}

int main() {
    int arr[ARRAY_SIZE];
    clock_t start, end;
    double cpu_time_used;

    // Initialize array
    for (int i = 0; i < ARRAY_SIZE; i++) {
        arr[i] = i + 1;
    }

    // Traditional sum
    start = clock();
    int traditional_result = traditional_sum(arr, ARRAY_SIZE);
    end = clock();
    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("Traditional Sum: %d\n", traditional_result);
    printf("Traditional Loop Time: %f seconds\n", cpu_time_used);

    // Optimized sum
    start = clock();
    int optimized_result = optimized_sum(arr, ARRAY_SIZE);
    end = clock();
    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("Optimized Sum: %d\n", optimized_result);
    printf("Optimized Loop Time: %f seconds\n", cpu_time_used);

    return 0;
}

Aqui está outro exemplo demonstrando múltiplas técnicas de otimização:

#include <stdio.h>

#define MAX_SIZE 1000

int main() {
    int numbers[MAX_SIZE];
    int even_sum = 0, odd_sum = 0;

    // Efficient initialization and summation
    for (int i = 0; i < MAX_SIZE; i++) {
        numbers[i] = i + 1;

        // Conditional sum with minimal branching
        even_sum += (numbers[i] % 2 == 0) * numbers[i];
        odd_sum += (numbers[i] % 2 != 0) * numbers[i];
    }

    printf("Sum of Even Numbers: %d\n", even_sum);
    printf("Sum of Odd Numbers: %d\n", odd_sum);

    return 0;
}

Principais técnicas de otimização demonstradas:

1. Desdobramento de loop (Loop unrolling) para reduzir a sobrecarga do loop
2. Minimizando previsões de ramificação
3. Combinando inicialização e processamento
4. Usando multiplicação para soma condicional

Compile e execute os programas com flags de otimização:

## Compile with basic optimization
gcc -O2 loop_optimization.c -o loop_optimization
./loop_optimization

## Compile with advanced optimization
gcc -O3 loop_optimization.c -o loop_optimization
./loop_optimization

Dicas de otimização adicionais:

• Use as flags do compilador -O2 ou -O3
• Minimize as chamadas de função dentro de loops
• Use tipos de dados apropriados
• Evite cálculos desnecessários
• Considere a movimentação de código invariante de loop (loop invariant code motion)

Resumo

Neste laboratório, você aprenderá os fundamentos dos loops while na programação C, incluindo como usar as diretivas break e continue para controlar o fluxo do loop. Você também explorará técnicas para filtrar elementos de array usando declarações condicionais e otimizar a eficiência do loop com várias diretivas. Ao final deste laboratório, você terá uma sólida compreensão de como implementar loops condicionais em C para resolver uma variedade de problemas de programação.