Структуры управления потоком выполнения в C++

Введение

В этом лабораторном занятии вы научитесь реализовывать различные структуры управления потоком выполнения в C++, включая одноблочные и многоблочные операторы if-else, операторы switch, циклы for с управлением счетчиком, циклы while с входным условием, циклы do-while с выходным условием и вложенные циклы. Вы также изучите использование операторов break и continue для управления выполнением циклов. Эти фундаментальные конструкции программирования являются обязательными для создания более сложных и динамических приложений на C++.

В рамках лабораторной работы рассматривается широкий спектр тем, начиная от написания условных операторов и заканчивая созданием циклов с различной логикой выполнения. По завершении этого лабораторного занятия вы получите твердую базу знаний о том, как использовать эти структуры управления потоком выполнения для того, чтобы сделать ваши программы на C++ более гибкими и адаптируемыми к различным сценариям.

Запись одноблочных и многоблочных операторов if-else

На этом этапе вы научитесь записывать одноблочные и многоблочные операторы if-else в C++. Условные операторы позволяют вашей программе принимать решения и выполнять различные блоки кода в зависимости от определенных условий.

Сначала перейдите в директорию проекта и создайте новый файл C++ для этого лабораторного занятия:

cd ~/project
touch conditional_statements.cpp

Откройте файл conditional_statements.cpp в WebIDE и добавьте следующий код, чтобы изучить одноблочные и многоблочные операторы if-else:

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

Скомпилируйте и запустите программу:

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

Пример вывода:

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

Разберём различные типы операторов if-else:

Одноблочный оператор if:
- Выполняет блок кода, если условие истинно.
- Не предусматривает альтернативного действия, если условие ложно.
Оператор if-else:
- Предоставляет два пути выполнения.
- Выполняет один блок, если условие истинно.
- Выполняет другой блок, если условие ложно.
Многоблочный оператор if-else:
- Позволяет проверить несколько условий.
- Использует else if для добавления дополнительных условий.
- Блок else служит в качестве варианта по умолчанию.

Основные моменты о операторах if-else:

Условия оцениваются сверху вниз.
Будет выполнен только один блок кода.
Используйте фигурные скобки { } для определения блоков кода.
В условиях используются операторы сравнения, такие как >, >=, <, <=, ==, !=.

Создание оператора switch с несколькими метками case

На этом этапе вы научитесь использовать оператор switch в C++ для обработки нескольких условий на основе одной переменной. Оператор switch представляет собой альтернативу множественным операторам if-else при сравнении переменной с различными константными значениями.

Сначала перейдите в директорию проекта и создайте новый файл C++:

cd ~/project
touch switch_statement.cpp

Откройте файл switch_statement.cpp в WebIDE и добавьте следующий код для изучения операторов 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;
}

Скомпилируйте и запустите программу:

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

Пример вывода:

Wednesday
Excellent performance!

Основные моменты о операторах switch:

Используется для выбора одного из многих блоков кода для выполнения.
Работает с целочисленными типами (int, char, enum).
Каждый case представляет возможное значение.
Оператор break предотвращает переход к следующему case.
default обрабатывает значения, не совпадающие с другими case.
Несколько case могут использовать один и тот же блок кода.

Важные правила оператора switch:

Каждый case должен заканчиваться оператором break или return.
case должны быть константными выражениями.
Будет выполнен только один блок кода.
default является необязательным, но рекомендуется использовать.

Инициализация счетчиковых циклов for

На этом этапе вы научитесь использовать счетчиковые циклы for в C++. Циклы for являются важными для выполнения блока кода определенное количество раз, что делает их идеальными для задач, которые требуют повторения с известным количеством итераций.

Сначала перейдите в директорию проекта и создайте новый файл C++:

cd ~/project
touch for_loops.cpp

Откройте файл for_loops.cpp в WebIDE и добавьте следующий код, чтобы изучить различные способы инициализации и использования циклов 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;
}

Скомпилируйте и запустите программу:

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

Пример вывода:

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

Основные компоненты цикла for:

Инициализация: int i = 1 - Устанавливает начальное значение счетчика.
Условие: i <= 5 - Определяет, когда цикл должен продолжаться.
Инкремент/Декремент: i++ - Изменяет счетчик после каждой итерации.

Важные характеристики цикла for:

Идеально подходит для известного количества итераций.
Может иметь несколько инструкций инициализации.
Может изменять несколько переменных на каждой итерации.
Гибко управляет выполнением цикла.

Создание циклов while с логикой входного контроля

На этом этапе вы научитесь использовать циклы while в C++. Цикл while представляет собой цикл с входным контролем, который повторно выполняет блок кода, пока заданное условие остается истинным. Условие проверяется перед каждой итерацией, что означает, что цикл может не выполниться вообще, если начальное условие ложно.

Сначала перейдите в директорию проекта и создайте новый файл C++:

cd ~/project
touch while_loops.cpp

Откройте файл while_loops.cpp в WebIDE и добавьте следующий код, чтобы изучить различные способы использования циклов 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;
}

Скомпилируйте и запустите программу:

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

Пример вывода:

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

Основные характеристики циклов while:

Условие проверяется перед каждой итерацией.
Цикл может не выполниться, если начальное условие ложно.
Требует ручного инкремента/обновления переменной цикла.
Полезен в ситуациях, когда количество итераций заранее неизвестно.

Важные компоненты цикла while:

Инициализация переменной цикла перед циклом.
Условие, которое контролирует выполнение цикла.
Обновление переменной цикла внутри тела цикла.

Реализация циклов do-while для логики выходного контроля

На этом этапе вы узнаете о циклах do-while в C++. В отличие от циклов while, циклы do-while имеют выходной контроль, то есть условие проверяется после выполнения тела цикла. Это гарантирует, что тело цикла выполнится хотя бы один раз, независимо от начального условия.

Сначала перейдите в директорию проекта и создайте новый файл C++:

cd ~/project
touch do_while_loops.cpp

Откройте файл do_while_loops.cpp в WebIDE и добавьте следующий код, чтобы изучить различные способы использования циклов 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;
}

Скомпилируйте и запустите программу:

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

Пример вывода:

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.

Основные характеристики циклов do-while:

Условие проверяется после выполнения тела цикла.
Гарантирует хотя бы одно выполнение цикла.
Полезен для валидации ввода и игр.
Синтаксис отличается от цикла while проверкой условия в конце.

Важные компоненты цикла do-while:

Ключевое слово do начинает тело цикла.
Тело цикла всегда выполняется хотя бы один раз.
Условие while оценивается после каждой итерации.
Точка с запятой ; обязательна после условия while.

Использование оператора break для досрочного выхода из циклов

На этом этапе вы научитесь использовать оператор break для досрочного выхода из циклов в C++. Оператор break позволяет немедленно завершить выполнение цикла и передать управление первой инструкции после цикла.

Сначала перейдите в директорию проекта и создайте новый файл C++:

cd ~/project
touch break_statement.cpp

Откройте файл break_statement.cpp в WebIDE и добавьте следующий код, чтобы изучить различные способы использования оператора 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;
}

Скомпилируйте и запустите программу:

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

Пример вывода:

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.

Основные характеристики оператора break:

Немедленно завершает выполнение самого внутреннего цикла.
Передает управление первой инструкции после цикла.
Может использоваться в циклах for, while и do-while.
Полезен для досрочного завершения цикла на основе условия.

Важные применения оператора break:

Выход из циклов при выполнении определенного условия.
Реализация алгоритмов поиска.
Создание интерактивных программ с вводом пользователя.
Предотвращение ненужных итераций.

Пропуск итераций цикла с использованием оператора continue

На этом этапе вы научитесь использовать оператор continue в C++ для пропуска текущей итерации цикла и перехода к следующей. Оператор continue позволяет выборочно пропускать части цикла на основе определенных условий.

Сначала перейдите в директорию проекта и создайте новый файл C++:

cd ~/project
touch continue_statement.cpp

Откройте файл continue_statement.cpp в WebIDE и добавьте следующий код, чтобы изучить различные способы использования оператора 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;
}

Скомпилируйте и запустите программу:

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

Пример вывода:

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

Основные характеристики оператора continue:

Пропускает оставшуюся часть текущей итерации цикла.
Передает управление следующей итерации цикла.
Может использоваться в циклах for, while и do-while.
Полезен для фильтрации или условной обработки.

Важные применения оператора continue:

Пропуск определенных итераций на основе условий.
Фильтрация данных в циклах.
Избегание ненужных вычислений.
Упрощение логики цикла.

Создание вложенных циклов для операций с матрицами

На этом этапе вы научитесь использовать вложенные циклы для выполнения операций с двумерными массивами (матрицами) в C++. Вложенные циклы позволяют перебирать строки и столбцы матрицы, что обеспечивает сложную обработку и вычисления с данными.

Сначала перейдите в директорию проекта и создайте новый файл C++:

cd ~/project
touch nested_loops.cpp

Откройте файл nested_loops.cpp в WebIDE и добавьте следующий код, чтобы изучить операции с матрицами с использованием вложенных циклов:

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

Скомпилируйте и запустите программу:

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

Пример вывода:

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

Основные характеристики вложенных циклов:

Внутренний цикл выполняет все свои итерации для каждой итерации внешнего цикла.
Полезны для работы с многомерными массивами.
Можно использовать для создания сложных шаблонов и выполнения операций с матрицами.
Обычно используются с двумерными массивами (матрицами) и многомерными структурами данных.

Важные концепции вложенных циклов:

Внешний цикл контролирует количество выполнений внутреннего цикла.
Каждый цикл имеет свою собственную счетную переменную.
Полезны для операций, основанных на строках и столбцах.
Можно использовать для генерации шаблонов, выполнения вычислений и обработки данных.

Предотвращение бесконечных циклов

На этом этапе вы научитесь предотвращать бесконечные циклы в C++ с помощью правильных механизмов управления циклами. Бесконечный цикл возникает, когда условие цикла никогда не становится ложным, и программа выполняется бесконечно.

Сначала перейдите в директорию проекта и создайте новый файл C++:

cd ~/project
touch infinite_loop_prevention.cpp

Откройте файл infinite_loop_prevention.cpp в WebIDE и добавьте следующий код, чтобы изучить различные стратегии предотвращения бесконечных циклов:

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

Скомпилируйте и запустите программу:

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

Пример вывода:

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

Основные стратегии предотвращения бесконечных циклов:

Установить максимальное количество итераций.
Использовать оператор break для выхода из цикла.
Реализовать валидацию ввода.
Добавить условные проверки для управления выполнением цикла.
Предоставить механизмы управления пользователем.

Важные методы предотвращения бесконечных циклов:

Всегда убедиться, что условие цикла может стать ложным.
Использовать счетные переменные для ограничения количества итераций.
Реализовать условия выхода внутри цикла.
Валидировать ввод пользователя.
Использовать break для выхода из цикла при необходимости.

Резюме

В этом практическом занятии вы научились реализовывать различные структуры управления потоком выполнения в C++, включая одноблочные и многоблочные операторы if-else, операторы switch, циклы for с управлением счетчиком, циклы while с входным условием, циклы do-while с выходным условием и вложенные циклы. Вы изучили использование операторов break и continue для управления выполнением циклов и узнали методы обработки бесконечных циклов. Эти структуры управления потоком выполнения являются фундаментальными в программировании на C++ и позволяют писать более сложные и динамичные программы, которые могут принимать решения и выполнять различные пути выполнения кода на основе определенных условий.

В рамках практического занятия были рассмотрены практические применения этих структур управления потоком выполнения с помощью практических упражнений по программированию, что позволило вам более глубоко понять их использование и приобрести способность эффективно применять их в своих собственных проектах на C++.