Estructuras de flujo de control en C++

Introducción

En este laboratorio, aprenderás cómo implementar diversas estructuras de flujo de control en C++, incluyendo declaraciones if-else de una y múltiples ramas, declaraciones switch, bucles for controlados por contador, bucles while controlados por entrada, bucles do-while controlados por salida y bucles anidados. También explorarás el uso de las declaraciones break y continue para controlar la ejecución de los bucles. Estas construcciones fundamentales de programación son esenciales para construir aplicaciones más complejas y dinámicas en C++.

El laboratorio cubre una variedad de temas, desde escribir declaraciones condicionales hasta crear bucles con diferentes lógicas de ejecución. Al final de este laboratorio, tendrás una comprensión sólida de cómo usar estas estructuras de flujo de control para hacer que tus programas en C++ sean más flexibles y adaptables a diferentes escenarios.

Escribir declaraciones if-else de una y múltiples ramas

En este paso, aprenderás cómo escribir declaraciones if-else de una y múltiples ramas en C++. Las declaraciones condicionales permiten que tu programa tome decisiones y ejecute diferentes bloques de código según condiciones específicas.

Primero, navega hasta el directorio del proyecto y crea un nuevo archivo C++ para este laboratorio:

cd ~/project
touch conditional_statements.cpp

Abre el archivo conditional_statements.cpp en el WebIDE y agrega el siguiente código para explorar las declaraciones if-else de una y múltiples ramas:

#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;
}

Compila y ejecuta el programa:

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

Ejemplo de salida:

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

Analicemos los diferentes tipos de declaraciones if-else:

Declaración if simple:
- Ejecuta un bloque de código si la condición es verdadera
- No hay acción alternativa si la condición es falsa
Declaración if-else:
- Proporciona dos caminos de ejecución
- Ejecuta un bloque si la condición es verdadera
- Ejecuta otro bloque si la condición es falsa
Declaración if-else de múltiples ramas:
- Permite verificar múltiples condiciones
- Utiliza else if para agregar más condiciones
- El bloque else sirve como caso predeterminado

Puntos clave sobre las declaraciones if-else:

Las condiciones se evalúan de arriba hacia abajo
Solo se ejecutará un bloque de código
Utiliza llaves { } para definir bloques de código
En las condiciones se utilizan operadores de comparación como >, >=, <, <=, ==, !=

Crear una declaración switch con múltiples etiquetas case

En este paso, aprenderás cómo usar la declaración switch en C++ para manejar múltiples condiciones basadas en una sola variable. La declaración switch proporciona una alternativa a múltiples declaraciones if-else cuando se compara una variable con diferentes valores constantes.

Primero, navega hasta el directorio del proyecto y crea un nuevo archivo C++:

cd ~/project
touch switch_statement.cpp

Abre el archivo switch_statement.cpp en el WebIDE y agrega el siguiente código para explorar las declaraciones 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;
}

Compila y ejecuta el programa:

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

Ejemplo de salida:

Wednesday
Excellent performance!

Puntos clave sobre las declaraciones switch:

Se utiliza para seleccionar uno de muchos bloques de código para ejecutar.
Funciona con tipos enteros (int, char, enum).
Cada case representa un posible valor.
La declaración break evita que se ejecute el siguiente case.
El case default maneja los valores no coincidentes con otros casos.
Varios casos pueden compartir el mismo bloque de código.

Reglas importantes de la declaración switch:

Cada case debe terminar con un break o return.
Los casos deben ser expresiones constantes.
Solo se ejecutará un bloque de código.
El case default es opcional pero se recomienda.

Inicializar bucles for controlados por contador

En este paso, aprenderás cómo usar bucles for controlados por contador en C++. Los bucles for son esenciales para ejecutar un bloque de código un número específico de veces, lo que los hace perfectos para tareas que requieran repetición con un número conocido de iteraciones.

Primero, navega hasta el directorio del proyecto y crea un nuevo archivo C++:

cd ~/project
touch for_loops.cpp

Abre el archivo for_loops.cpp en el WebIDE y agrega el siguiente código para explorar diferentes formas de inicializar y usar bucles 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;
}

Compila y ejecuta el programa:

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

Ejemplo de salida:

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 clave de un bucle for:

Inicialización: int i = 1 - Establece el valor inicial del contador.
Condición: i <= 5 - Define cuándo el bucle debe continuar.
Incremento/Decremento: i++ - Cambia el contador después de cada iteración.

Características importantes de los bucles for:

Ideal para un número conocido de iteraciones.
Puede tener múltiples declaraciones de inicialización.
Puede modificar múltiples variables en cada iteración.
Flexible en el control de la ejecución del bucle.

Crear bucles while con lógica controlada por entrada

En este paso, aprenderás cómo usar bucles while en C++. Un bucle while es un bucle controlado por entrada que ejecuta repetidamente un bloque de código siempre y cuando una condición especificada sea verdadera. La condición se verifica antes de cada iteración, lo que significa que el bucle puede no ejecutarse en absoluto si la condición inicial es falsa.

Primero, navega hasta el directorio del proyecto y crea un nuevo archivo C++:

cd ~/project
touch while_loops.cpp

Abre el archivo while_loops.cpp en el WebIDE y agrega el siguiente código para explorar diferentes formas de usar bucles 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;
}

Compila y ejecuta el programa:

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

Ejemplo de salida:

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 clave de los bucles while:

La condición se verifica antes de cada iteración.
El bucle puede no ejecutarse si la condición inicial es falsa.
Requiere el incremento/actualización manual de la variable del bucle.
Útil para situaciones en las que el número de iteraciones no se conoce de antemano.

Componentes importantes de los bucles while:

Inicialización de la variable del bucle antes del bucle.
Condición que controla la ejecución del bucle.
Actualización de la variable del bucle dentro del cuerpo del bucle.

Implementar bucles do-while para lógica controlada por salida

En este paso, aprenderás sobre los bucles do-while en C++. A diferencia de los bucles while, los bucles do-while son controlados por salida, lo que significa que la condición se verifica después de ejecutar el cuerpo del bucle. Esto garantiza que el cuerpo del bucle se ejecute al menos una vez, independientemente de la condición inicial.

Primero, navega hasta el directorio del proyecto y crea un nuevo archivo C++:

cd ~/project
touch do_while_loops.cpp

Abre el archivo do_while_loops.cpp en el WebIDE y agrega el siguiente código para explorar diferentes formas de usar bucles 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;
}

Compila y ejecuta el programa:

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

Ejemplo de salida:

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 clave de los bucles do-while:

La condición se verifica después de ejecutar el cuerpo del bucle.
Garantiza al menos una ejecución del bucle.
Útil para validación de entrada y juegos.
La sintaxis difiere del bucle while al verificar la condición al final.

Componentes importantes de los bucles do-while:

La palabra clave do inicia el cuerpo del bucle.
El cuerpo del bucle siempre se ejecuta al menos una vez.
La condición while se evalúa después de cada iteración.
Se requiere un punto y coma ; después de la condición while.

Usar break para salir de los bucles antes de tiempo

En este paso, aprenderás cómo usar la declaración break para salir prematuramente de los bucles en C++. La declaración break te permite terminar inmediatamente un bucle y transferir el control a la primera declaración después del bucle.

Primero, navega hasta el directorio del proyecto y crea un nuevo archivo C++:

cd ~/project
touch break_statement.cpp

Abre el archivo break_statement.cpp en el WebIDE y agrega el siguiente código para explorar diferentes formas de usar la declaración 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;
}

Compila y ejecuta el programa:

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

Ejemplo de salida:

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 clave de la declaración break:

Termina inmediatamente el bucle más interno.
Transfiere el control a la primera declaración después del bucle.
Puede usarse en bucles for, while y do-while.
Útil para la terminación temprana de un bucle basada en una condición.

Usos importantes de la declaración break:

Salir de los bucles cuando se cumple una condición específica.
Implementar algoritmos de búsqueda.
Crear programas interactivos con entrada del usuario.
Evitar iteraciones innecesarias.

Saltar iteraciones de bucle con la declaración continue

En este paso, aprenderás cómo usar la declaración continue en C++ para saltar la iteración actual de un bucle y pasar a la siguiente iteración. La declaración continue te permite omitir selectivamente partes de un bucle basadas en condiciones específicas.

Primero, navega hasta el directorio del proyecto y crea un nuevo archivo C++:

cd ~/project
touch continue_statement.cpp

Abre el archivo continue_statement.cpp en el WebIDE y agrega el siguiente código para explorar diferentes formas de usar la declaración 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;
}

Compila y ejecuta el programa:

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

Ejemplo de salida:

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 clave de la declaración continue:

Omite el resto de la iteración actual del bucle.
Transfiere el control a la siguiente iteración del bucle.
Puede usarse en bucles for, while y do-while.
Útil para filtrado o procesamiento condicional.

Usos importantes de la declaración continue:

Saltar iteraciones específicas basadas en condiciones.
Filtrar datos en bucles.
Evitar cálculos innecesarios.
Simplificar la lógica de los bucles.

Crear bucles anidados para operaciones con matrices

En este paso, aprenderás cómo usar bucles anidados para realizar operaciones en matrices (arrays bidimensionales) en C++. Los bucles anidados te permiten iterar a través de las filas y columnas de una matriz, lo que posibilita la manipulación y cálculo complejos de datos.

Primero, navega hasta el directorio del proyecto y crea un nuevo archivo C++:

cd ~/project
touch nested_loops.cpp

Abre el archivo nested_loops.cpp en el WebIDE y agrega el siguiente código para explorar operaciones con matrices utilizando bucles anidados:

#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;
}

Compila y ejecuta el programa:

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

Ejemplo de salida:

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 clave de los bucles anidados:

Un bucle interno completa todas sus iteraciones para cada iteración del bucle externo.
Útiles para trabajar con arrays multidimensionales.
Pueden usarse para crear patrones complejos y realizar operaciones con matrices.
Típicamente se utilizan con arrays bidimensionales (matrices) y estructuras de datos multidimensionales.

Conceptos importantes de los bucles anidados:

El bucle externo controla el número de veces que se ejecuta el bucle interno.
Cada bucle tiene su propia variable contador.
Útiles para operaciones basadas en filas y columnas.
Pueden usarse para generar patrones, realizar cálculos y manipular datos.

Manejar la prevención de bucles infinitos

En este paso, aprenderás cómo prevenir bucles infinitos en C++ implementando adecuados mecanismos de control de bucles. Un bucle infinito ocurre cuando la condición de un bucle nunca se vuelve falsa, lo que hace que el programa se ejecute indefinidamente.

Primero, navega hasta el directorio del proyecto y crea un nuevo archivo C++:

cd ~/project
touch infinite_loop_prevention.cpp

Abre el archivo infinite_loop_prevention.cpp en el WebIDE y agrega el siguiente código para explorar diferentes estrategias para prevenir bucles 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;
}

Compila y ejecuta el programa:

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

Ejemplo de salida:

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

Estrategias clave para prevenir bucles infinitos:

Establecer un límite máximo de iteraciones.
Usar la declaración break para salir de los bucles.
Implementar validación de entrada.
Agregar comprobaciones condicionales para controlar la ejecución del bucle.
Proporcionar mecanismos de control para el usuario.

Técnicas importantes de prevención de bucles infinitos:

Siempre asegúrate de que la condición del bucle pueda volverse falsa.
Utiliza variables contador para limitar las iteraciones.
Implementa condiciones de salida dentro del bucle.
Valida la entrada del usuario.
Utiliza break para salir de los bucles cuando sea necesario.

Resumen

En este laboratorio, aprendiste cómo implementar diversas estructuras de flujo de control en C++, incluyendo declaraciones if-else de una y múltiples ramas, declaraciones switch, bucles for controlados por contador, bucles while controlados por entrada, bucles do-while controlados por salida y bucles anidados. Exploraste el uso de las declaraciones break y continue para controlar la ejecución de los bucles y aprendiste técnicas para manejar bucles infinitos. Estas estructuras de flujo de control son fundamentales en la programación en C++, ya que te permiten escribir programas más complejos y dinámicos que pueden tomar decisiones y ejecutar diferentes caminos de código basados en condiciones específicas.

El laboratorio cubrió la aplicación práctica de estas estructuras de flujo de control a través de ejercicios prácticos de codificación, lo que te permitió desarrollar una comprensión más profunda de su uso y la capacidad de aplicarlas de manera efectiva en tus propios proyectos de C++.