Estruturas de Controle de Fluxo em C++: Guia Completo

Introdução

Neste laboratório, você aprenderá como implementar várias estruturas de controle de fluxo em C++, incluindo instruções if-else de ramificação única e múltipla, instruções switch, loops for controlados por contador, loops while controlados por entrada, loops do-while controlados por saída e loops aninhados. Você também explorará o uso das instruções break e continue para controlar a execução de loops. Essas construções fundamentais de programação são essenciais para construir aplicações mais complexas e dinâmicas em C++.

O laboratório cobre uma variedade de tópicos, desde a escrita de instruções condicionais até a criação de loops com diferentes lógicas de execução. Ao final deste laboratório, você terá uma sólida compreensão de como usar essas estruturas de controle de fluxo para tornar seus programas C++ mais flexíveis e adaptáveis a diferentes cenários.

Escreva instruções if-else de ramificação única e múltipla

Nesta etapa, você aprenderá como escrever instruções if-else de ramificação única e múltipla em C++. As instruções condicionais permitem que seu programa tome decisões e execute diferentes blocos de código com base em condições específicas.

Primeiro, navegue até o diretório do projeto e crie um novo arquivo C++ para este laboratório:

cd ~/project
touch conditional_statements.cpp

Abra o arquivo conditional_statements.cpp no WebIDE e adicione o seguinte código para explorar as instruções if-else de ramificação única e múltipla:

#include <iostream>

int main() {
    // Single if statement
    int number = 10;
    if (number > 5) {
        std::cout << "Number is greater than 5" << std::endl;
    }

    // if-else statement
    int age = 20;
    if (age >= 18) {
        std::cout << "You are an adult" << std::endl;
    } else {
        std::cout << "You are a minor" << std::endl;
    }

    // Multi-branch if-else statement
    int score = 75;
    if (score >= 90) {
        std::cout << "Grade: A" << std::endl;
    } else if (score >= 80) {
        std::cout << "Grade: B" << std::endl;
    } else if (score >= 70) {
        std::cout << "Grade: C" << std::endl;
    } else if (score >= 60) {
        std::cout << "Grade: D" << std::endl;
    } else {
        std::cout << "Grade: F" << std::endl;
    }

    return 0;
}

Compile e execute o programa:

g++ conditional_statements.cpp -o conditional_statements
./conditional_statements

Exemplo de saída:

Number is greater than 5
You are an adult
Grade: C

Vamos detalhar os diferentes tipos de instruções if-else:

Instrução if única:
- Executa um bloco de código se a condição for verdadeira
- Nenhuma ação alternativa se a condição for falsa
Instrução if-else:
- Fornece dois caminhos de execução
- Executa um bloco se a condição for verdadeira
- Executa outro bloco se a condição for falsa
Instrução if-else de múltiplas ramificações:
- Permite que várias condições sejam verificadas
- Usa else if para adicionar mais condições
- O bloco else serve como um caso padrão

Pontos-chave sobre as instruções if-else:

As condições são avaliadas de cima para baixo
Apenas um bloco de código será executado
Use chaves { } para definir blocos de código
Operadores de comparação como >, >=, <, <=, ==, != são usados em condições

Crie uma instrução switch com múltiplos rótulos case

Nesta etapa, você aprenderá como usar a instrução switch em C++ para lidar com múltiplas condições com base em uma única variável. A instrução switch fornece uma alternativa a múltiplas instruções if-else ao comparar uma variável com diferentes valores constantes.

Primeiro, navegue até o diretório do projeto e crie um novo arquivo C++:

cd ~/project
touch switch_statement.cpp

Abra o arquivo switch_statement.cpp no WebIDE e adicione o seguinte código para explorar as instruções switch:

#include <iostream>

int main() {
    // Basic switch statement with multiple case labels
    int dayNumber = 3;

    switch (dayNumber) {
        case 1:
            std::cout << "Monday" << std::endl;
            break;
        case 2:
            std::cout << "Tuesday" << std::endl;
            break;
        case 3:
            std::cout << "Wednesday" << std::endl;
            break;
        case 4:
            std::cout << "Thursday" << std::endl;
            break;
        case 5:
            std::cout << "Friday" << std::endl;
            break;
        case 6:
            std::cout << "Saturday" << std::endl;
            break;
        case 7:
            std::cout << "Sunday" << std::endl;
            break;
        default:
            std::cout << "Invalid day number" << std::endl;
    }

    // Switch statement with multiple cases sharing the same code block
    char grade = 'B';

    switch (grade) {
        case 'A':
        case 'B':
            std::cout << "Excellent performance!" << std::endl;
            break;
        case 'C':
        case 'D':
            std::cout << "Good performance" << std::endl;
            break;
        case 'F':
            std::cout << "Need improvement" << std::endl;
            break;
        default:
            std::cout << "Invalid grade" << std::endl;
    }

    return 0;
}

Compile e execute o programa:

g++ switch_statement.cpp -o switch_statement
./switch_statement

Exemplo de saída:

Wednesday
Excellent performance!

Pontos-chave sobre as instruções switch:

Usado para selecionar um de muitos blocos de código para executar
Funciona com tipos integrais (int, char, enum)
Cada case representa um valor possível
A instrução break impede a queda para o próximo case
O default case lida com valores que não correspondem a outros cases
Múltiplos cases podem compartilhar o mesmo bloco de código

Regras importantes da instrução switch:

Cada case deve terminar com um break ou return
Os cases devem ser expressões constantes
Apenas um bloco de código será executado
O default case é opcional, mas recomendado

Inicialize loops for controlados por contador

Nesta etapa, você aprenderá como usar laços for controlados por contador em C++. Os laços for são essenciais para executar um bloco de código um número específico de vezes, tornando-os perfeitos para tarefas que exigem repetição com um número conhecido de iterações.

Primeiro, navegue até o diretório do projeto e crie um novo arquivo C++:

cd ~/project
touch for_loops.cpp

Abra o arquivo for_loops.cpp no WebIDE e adicione o seguinte código para explorar diferentes maneiras de inicializar e usar laços for:

#include <iostream>

int main() {
    // Basic counter-controlled for loop
    std::cout << "Counting from 1 to 5:" << std::endl;
    for (int i = 1; i <= 5; i++) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    // For loop with multiple statements in initialization
    std::cout << "Counting even numbers from 0 to 10:" << std::endl;
    for (int j = 0, k = 10; j <= k; j += 2) {
        std::cout << j << " ";
    }
    std::cout << std::endl;

    // For loop with multiplication table
    std::cout << "Multiplication table for 5:" << std::endl;
    for (int m = 1; m <= 10; m++) {
        std::cout << "5 x " << m << " = " << (5 * m) << std::endl;
    }

    return 0;
}

Compile e execute o programa:

g++ for_loops.cpp -o for_loops
./for_loops

Exemplo de saída:

Counting from 1 to 5:
1 2 3 4 5
Counting even numbers from 0 to 10:
0 2 4 6 8 10
Multiplication table for 5:
5 x 1 = 5
5 x 2 = 10
5 x 3 = 15
5 x 4 = 20
5 x 5 = 25
5 x 6 = 30
5 x 7 = 35
5 x 8 = 40
5 x 9 = 45
5 x 10 = 50

Componentes-chave de um laço for:

Inicialização: int i = 1 - Define o valor inicial do contador
Condição: i <= 5 - Define quando o laço deve continuar
Incremento/Decremento: i++ - Altera o contador após cada iteração

Características importantes dos laços for:

Ideal para um número conhecido de iterações
Pode ter múltiplas instruções de inicialização
Pode modificar múltiplas variáveis em cada iteração
Flexível no controle da execução do laço

Crie loops while com lógica de controle de entrada

Nesta etapa, você aprenderá como usar laços while em C++. Um laço while é um laço controlado por entrada que executa repetidamente um bloco de código enquanto uma condição especificada permanecer verdadeira. A condição é verificada antes de cada iteração, o que significa que o laço pode não ser executado se a condição inicial for falsa.

Primeiro, navegue até o diretório do projeto e crie um novo arquivo C++:

cd ~/project
touch while_loops.cpp

Abra o arquivo while_loops.cpp no WebIDE e adicione o seguinte código para explorar diferentes maneiras de usar laços while:

#include <iostream>

int main() {
    // Basic while loop counting
    std::cout << "Counting from 1 to 5:" << std::endl;
    int count = 1;
    while (count <= 5) {
        std::cout << count << " ";
        count++;
    }
    std::cout << std::endl;

    // While loop with user input validation
    int userNumber;
    std::cout << "Enter a number between 1 and 10: ";
    std::cin >> userNumber;

    while (userNumber < 1 || userNumber > 10) {
        std::cout << "Invalid input. Enter a number between 1 and 10: ";
        std::cin >> userNumber;
    }
    std::cout << "You entered a valid number: " << userNumber << std::endl;

    // While loop calculating factorial
    int number = 5;
    int factorial = 1;
    int i = 1;

    std::cout << "Calculating factorial of " << number << ":" << std::endl;
    while (i <= number) {
        factorial *= i;
        i++;
    }
    std::cout << number << "! = " << factorial << std::endl;

    return 0;
}

Compile e execute o programa:

g++ while_loops.cpp -o while_loops
./while_loops

Exemplo de saída:

Counting from 1 to 5:
1 2 3 4 5
Enter a number between 1 and 10: 15
Invalid input. Enter a number between 1 and 10: 7
You entered a valid number: 7
Calculating factorial of 5:
5! = 120

Características-chave dos laços while:

A condição é verificada antes de cada iteração
O laço pode não ser executado se a condição inicial for falsa
Requer incremento/atualização manual da variável do laço
Útil para situações em que o número de iterações não é conhecido de antemão

Componentes importantes do laço while:

Inicialização da variável do laço antes do laço
Condição que controla a execução do laço
Atualização da variável do laço dentro do corpo do laço

Implementar loops do-while para lógica de controle de saída

Nesta etapa, você aprenderá sobre laços do-while em C++. Ao contrário dos laços while, os laços do-while são controlados por saída, o que significa que a condição é verificada após a execução do corpo do laço. Isso garante que o corpo do laço seja executado pelo menos uma vez, independentemente da condição inicial.

Primeiro, navegue até o diretório do projeto e crie um novo arquivo C++:

cd ~/project
touch do_while_loops.cpp

Abra o arquivo do_while_loops.cpp no WebIDE e adicione o seguinte código para explorar diferentes maneiras de usar laços do-while:

#include <iostream>
#include <cstdlib>
#include <ctime>

int main() {
    // Basic do-while loop for user input validation
    int userNumber;
    do {
        std::cout << "Enter a number between 1 and 10: ";
        std::cin >> userNumber;
    } while (userNumber < 1 || userNumber > 10);
    std::cout << "You entered a valid number: " << userNumber << std::endl;

    // Simulating a dice rolling game
    srand(time(0));  // Seed for random number generation
    int attempts = 0;
    int targetNumber = 6;
    int diceRoll;

    std::cout << "Dice Rolling Game:" << std::endl;
    do {
        diceRoll = rand() % 6 + 1;  // Generate random number between 1 and 6
        attempts++;
        std::cout << "Roll " << attempts << ": You rolled " << diceRoll << std::endl;
    } while (diceRoll != targetNumber);

    std::cout << "Congratulations! You rolled the target number "
              << targetNumber << " in " << attempts << " attempts." << std::endl;

    return 0;
}

Compile e execute o programa:

g++ do_while_loops.cpp -o do_while_loops
./do_while_loops

Exemplo de saída:

Enter a number between 1 and 10: 15
Enter a number between 1 and 10: 7
You entered a valid number: 7
Dice Rolling Game:
Roll 1: You rolled 1
Roll 2: You rolled 5
Roll 3: You rolled 2
Roll 4: You rolled 5
Roll 5: You rolled 5
Roll 6: You rolled 3
Roll 7: You rolled 4
Roll 8: You rolled 2
Roll 9: You rolled 2
Roll 10: You rolled 2
Roll 11: You rolled 2
Roll 12: You rolled 2
Roll 13: You rolled 1
Roll 14: You rolled 1
Roll 15: You rolled 6
Congratulations! You rolled the target number 6 in 15 attempts.

Características-chave dos laços do-while:

A condição é verificada após a execução do corpo do laço
Garante pelo menos uma execução do laço
Útil para validação de entrada e jogos
A sintaxe difere do laço while por verificar a condição no final

Componentes importantes do laço do-while:

A palavra-chave do inicia o corpo do laço
O corpo do laço é sempre executado pelo menos uma vez
A condição while é avaliada após cada iteração
Ponto e vírgula ; é necessário após a condição while

Usar break para sair de loops antecipadamente

Nesta etapa, você aprenderá como usar a instrução break para sair de laços prematuramente em C++. A instrução break permite que você termine imediatamente um laço e transfira o controle para a primeira instrução após o laço.

Primeiro, navegue até o diretório do projeto e crie um novo arquivo C++:

cd ~/project
touch break_statement.cpp

Abra o arquivo break_statement.cpp no WebIDE e adicione o seguinte código para explorar diferentes maneiras de usar a instrução break:

#include <iostream>
#include <cstdlib>
#include <ctime>

int main() {
    // Breaking out of a for loop when a condition is met
    std::cout << "Finding the first even number:" << std::endl;
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            std::cout << "First even number found: " << i << std::endl;
            break;
        }
    }

    // Simulating a number guessing game
    srand(time(0));  // Seed for random number generation
    int targetNumber = rand() % 10 + 1;  // Random number between 1 and 10
    int guess;
    int attempts = 0;

    std::cout << "\nNumber Guessing Game:" << std::endl;
    while (true) {
        std::cout << "Enter your guess (1-10): ";
        std::cin >> guess;
        attempts++;

        if (guess == targetNumber) {
            std::cout << "Congratulations! You guessed the number in "
                      << attempts << " attempts." << std::endl;
            break;
        } else if (guess < targetNumber) {
            std::cout << "Too low. Try again." << std::endl;
        } else {
            std::cout << "Too high. Try again." << std::endl;
        }
    }

    return 0;
}

Compile e execute o programa:

g++ break_statement.cpp -o break_statement
./break_statement

Exemplo de saída:

Finding the first even number:
First even number found: 2

Number Guessing Game:
Enter your guess (1-10): 5
Too low. Try again.
Enter your guess (1-10): 8
Too high. Try again.
Enter your guess (1-10): 6
Congratulations! You guessed the number in 3 attempts.

Características-chave da instrução break:

Termina imediatamente o laço mais interno
Transfere o controle para a primeira instrução após o laço
Pode ser usado em laços for, while e do-while
Útil para terminação antecipada do laço com base em uma condição

Usos importantes da instrução break:

Sair de laços quando uma condição específica é atendida
Implementando algoritmos de busca
Criando programas interativos com entrada do usuário
Prevenindo iterações desnecessárias

Pular iterações de loop com a instrução continue

Nesta etapa, você aprenderá como usar a instrução continue em C++ para pular a iteração atual de um laço e passar para a próxima iteração. A instrução continue permite que você pule seletivamente partes de um laço com base em condições específicas.

Primeiro, navegue até o diretório do projeto e crie um novo arquivo C++:

cd ~/project
touch continue_statement.cpp

Abra o arquivo continue_statement.cpp no WebIDE e adicione o seguinte código para explorar diferentes maneiras de usar a instrução continue:

#include <iostream>

int main() {
    // Skipping even numbers in a loop
    std::cout << "Printing odd numbers between 1 and 10:" << std::endl;
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            continue;  // Skip even numbers
        }
        std::cout << i << " ";
    }
    std::cout << std::endl;

    // Filtering out negative numbers in a sum calculation
    int sum = 0;
    int numbers[] = {5, -3, 10, -7, 8, -2, 15};
    int arraySize = sizeof(numbers) / sizeof(numbers[0]);

    std::cout << "\nCalculating sum of positive numbers:" << std::endl;
    for (int j = 0; j < arraySize; j++) {
        if (numbers[j] < 0) {
            continue;  // Skip negative numbers
        }
        sum += numbers[j];
        std::cout << "Added: " << numbers[j] << ", Current Sum: " << sum << std::endl;
    }
    std::cout << "Final Sum of Positive Numbers: " << sum << std::endl;

    return 0;
}

Compile e execute o programa:

g++ continue_statement.cpp -o continue_statement
./continue_statement

Exemplo de saída:

Printing odd numbers between 1 and 10:
1 3 5 7 9

Calculating sum of positive numbers:
Added: 5, Current Sum: 5
Added: 10, Current Sum: 15
Added: 8, Current Sum: 23
Added: 15, Current Sum: 38
Final Sum of Positive Numbers: 38

Características-chave da instrução continue:

Pula o restante da iteração atual do laço
Transfere o controle para a próxima iteração do laço
Pode ser usado em laços for, while e do-while
Útil para filtragem ou processamento condicional

Usos importantes da instrução continue:

Pular iterações específicas com base em condições
Filtrar dados em laços
Evitar cálculos desnecessários
Simplificar a lógica do laço

Criar Loops Aninhados para Operações de Matriz

Nesta etapa, você aprenderá como usar laços aninhados para realizar operações em arrays 2D (matrizes) em C++. Laços aninhados permitem que você itere pelas linhas e colunas de uma matriz, possibilitando a manipulação e os cálculos de dados complexos.

Primeiro, navegue até o diretório do projeto e crie um novo arquivo C++:

cd ~/project
touch nested_loops.cpp

Abra o arquivo nested_loops.cpp no WebIDE e adicione o seguinte código para explorar operações de matriz usando laços aninhados:

#include <iostream>
#include <iomanip>

int main() {
    // Define a 3x3 matrix
    int matrix[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    // Print the original matrix
    std::cout << "Original Matrix:" << std::endl;
    for (int row = 0; row < 3; row++) {
        for (int col = 0; col < 3; col++) {
            std::cout << std::setw(4) << matrix[row][col];
        }
        std::cout << std::endl;
    }

    // Calculate row sums
    std::cout << "\nRow Sums:" << std::endl;
    for (int row = 0; row < 3; row++) {
        int rowSum = 0;
        for (int col = 0; col < 3; col++) {
            rowSum += matrix[row][col];
        }
        std::cout << "Row " << row + 1 << " Sum: " << rowSum << std::endl;
    }

    // Create and print a multiplication table
    std::cout << "\nMultiplication Table:" << std::endl;
    for (int i = 1; i <= 5; i++) {
        for (int j = 1; j <= 5; j++) {
            std::cout << std::setw(4) << (i * j);
        }
        std::cout << std::endl;
    }

    return 0;
}

Compile e execute o programa:

g++ nested_loops.cpp -o nested_loops
./nested_loops

Exemplo de saída:

Original Matrix:
   1   2   3
   4   5   6
   7   8   9

Row Sums:
Row 1 Sum: 6
Row 2 Sum: 15
Row 3 Sum: 24

Multiplication Table:
   1   2   3   4   5
   2   4   6   8  10
   3   6   9  12  15
   4   8  12  16  20
   5  10  15  20  25

Características-chave dos laços aninhados:

Um laço interno completa todas as suas iterações para cada iteração do laço externo
Útil para trabalhar com arrays multidimensionais
Pode ser usado para criar padrões complexos e realizar operações de matriz
Tipicamente usado com arrays 2D (matrizes) e estruturas de dados multidimensionais

Conceitos importantes de laços aninhados:

O laço externo controla o número de vezes que o laço interno é executado
Cada laço tem sua própria variável de contador
Útil para operações baseadas em linhas e colunas
Pode ser usado para gerar padrões, realizar cálculos e manipular dados

Lidar com a Prevenção de Loops Infinitos

Nesta etapa, você aprenderá como prevenir laços infinitos em C++ implementando mecanismos adequados de controle de laço. Um laço infinito ocorre quando a condição de um laço nunca se torna falsa, fazendo com que o programa seja executado indefinidamente.

Primeiro, navegue até o diretório do projeto e crie um novo arquivo C++:

cd ~/project
touch infinite_loop_prevention.cpp

Abra o arquivo infinite_loop_prevention.cpp no WebIDE e adicione o seguinte código para explorar diferentes estratégias para prevenir laços infinitos:

#include <iostream>
#include <cstdlib>
#include <ctime>

int main() {
    // Example 1: Preventing infinite loop with a maximum iteration limit
    std::cout << "Example 1: Iteration Limit Prevention" << std::endl;
    int counter = 0;
    const int MAX_ITERATIONS = 5;

    while (true) {
        std::cout << "Iteration: " << counter + 1 << std::endl;
        counter++;

        if (counter >= MAX_ITERATIONS) {
            std::cout << "Maximum iterations reached. Breaking the loop." << std::endl;
            break;
        }
    }

    // Example 2: User-controlled loop with input validation
    std::cout << "\nExample 2: User-Controlled Loop" << std::endl;
    char continueChoice;
    int attempts = 0;
    const int MAX_ATTEMPTS = 3;

    do {
        std::cout << "Enter a number (1-10): ";
        int userNumber;
        std::cin >> userNumber;

        if (userNumber >= 1 && userNumber <= 10) {
            std::cout << "Valid number entered: " << userNumber << std::endl;
            break;
        }

        attempts++;
        std::cout << "Invalid input. Attempts left: " << MAX_ATTEMPTS - attempts << std::endl;

        if (attempts >= MAX_ATTEMPTS) {
            std::cout << "Maximum attempts reached. Exiting." << std::endl;
            break;
        }

        std::cout << "Do you want to try again? (y/n): ";
        std::cin >> continueChoice;
    } while (continueChoice == 'y' || continueChoice == 'Y');

    // Example 3: Random number game with controlled iterations
    std::cout << "\nExample 3: Random Number Game" << std::endl;
    srand(time(0));  // Seed for random number generation
    int targetNumber = rand() % 10 + 1;
    int guess;
    int gameAttempts = 0;
    const int MAX_GAME_ATTEMPTS = 4;

    std::cout << "Guess the number between 1 and 10" << std::endl;
    while (gameAttempts < MAX_GAME_ATTEMPTS) {
        std::cout << "Attempt " << gameAttempts + 1 << ": Enter your guess: ";
        std::cin >> guess;

        if (guess == targetNumber) {
            std::cout << "Congratulations! You guessed the number." << std::endl;
            break;
        }

        gameAttempts++;

        if (gameAttempts >= MAX_GAME_ATTEMPTS) {
            std::cout << "Sorry, you've run out of attempts. The number was "
                      << targetNumber << std::endl;
            break;
        }
    }

    return 0;
}

Compile e execute o programa:

g++ infinite_loop_prevention.cpp -o infinite_loop_prevention
./infinite_loop_prevention

Exemplo de saída:

Example 1: Iteration Limit Prevention
Iteration: 1
Iteration: 2
Iteration: 3
Iteration: 4
Iteration: 5
Maximum iterations reached. Breaking the loop.

Example 2: User-Controlled Loop
Enter a number (1-10): 1
Valid number entered: 1

Example 3: Random Number Game
Guess the number between 1 and 10
Attempt 1: Enter your guess: 2
Attempt 2: Enter your guess: 3
Attempt 3: Enter your guess: 4
Attempt 4: Enter your guess: 5
Sorry, you've run out of attempts. The number was 8

Estratégias-chave para prevenir laços infinitos:

Definir um limite máximo de iteração
Usar a instrução break para sair de laços
Implementar validação de entrada
Adicionar verificações condicionais para controlar a execução do laço
Fornecer mecanismos de controle do usuário

Técnicas importantes de prevenção de laços infinitos:

Sempre garantir que a condição do laço possa se tornar falsa
Usar variáveis de contador para limitar as iterações
Implementar condições de saída dentro do laço
Validar a entrada do usuário
Usar break para sair de laços quando necessário

Resumo

Neste laboratório, você aprendeu como implementar várias estruturas de controle de fluxo em C++, incluindo instruções if-else de ramificação única e múltipla, instruções switch, laços for controlados por contador, laços while controlados por entrada, laços do-while controlados por saída e laços aninhados. Você explorou o uso das instruções break e continue para controlar a execução do laço e aprendeu técnicas para lidar com laços infinitos. Essas estruturas de controle de fluxo são fundamentais na programação C++, permitindo que você escreva programas mais complexos e dinâmicos que podem tomar decisões e executar diferentes caminhos de código com base em condições específicas.

O laboratório abordou a aplicação prática dessas estruturas de controle de fluxo por meio de exercícios de codificação práticos, permitindo que você desenvolva uma compreensão mais profunda de seu uso e a capacidade de aplicá-las efetivamente em seus próprios projetos C++.