C++ 제어 흐름 구조

소개

이 랩에서는 C++ 에서 다양한 제어 흐름 구조를 구현하는 방법을 배우게 됩니다. 여기에는 단일 및 다중 분기 if-else 문, switch 문, 카운터 제어 for 루프, 진입 제어 while 루프, 종료 제어 do-while 루프, 그리고 중첩 루프가 포함됩니다. 또한 루프 실행을 제어하기 위한 break 및 continue 문의 사용법도 살펴볼 것입니다. 이러한 기본적인 프로그래밍 구조는 C++ 에서 더 복잡하고 동적인 애플리케이션을 구축하는 데 필수적입니다.

이 랩은 조건문을 작성하는 것부터 다양한 실행 로직을 가진 루프를 생성하는 것까지 다양한 주제를 다룹니다. 이 랩을 마치면 이러한 제어 흐름 구조를 사용하여 C++ 프로그램을 다양한 시나리오에 더 유연하고 적응 가능하게 만드는 방법에 대한 확실한 이해를 갖게 될 것입니다.

단일 및 다중 분기 if-else 문 작성

이 단계에서는 C++ 에서 단일 및 다중 분기 if-else 문을 작성하는 방법을 배우게 됩니다. 조건문은 프로그램이 결정을 내리고 특정 조건에 따라 다른 코드 블록을 실행할 수 있도록 합니다.

먼저, 프로젝트 디렉토리로 이동하여 이 랩을 위한 새로운 C++ 파일을 생성합니다.

cd ~/project
touch conditional_statements.cpp

WebIDE 에서 conditional_statements.cpp 파일을 열고 다음 코드를 추가하여 단일 및 다중 분기 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 문을 자세히 살펴보겠습니다.

1. 단일 if 문:

   • 조건이 참이면 코드 블록을 실행합니다.
   • 조건이 거짓일 경우 대체 작업이 없습니다.

2. if-else 문:

   • 두 개의 실행 경로를 제공합니다.
   • 조건이 참이면 한 블록을 실행합니다.
   • 조건이 거짓이면 다른 블록을 실행합니다.

3. 다중 분기 if-else 문:

   • 여러 조건을 확인할 수 있습니다.
   • else if를 사용하여 더 많은 조건을 추가합니다.
   • else 블록은 기본 케이스 역할을 합니다.

if-else 문에 대한 주요 사항:

• 조건은 위에서 아래로 평가됩니다.
• 하나의 코드 블록만 실행됩니다.
• 코드 블록을 정의하려면 중괄호 { }를 사용합니다.
• >, >=, <, <=, ==, !=와 같은 비교 연산자가 조건에 사용됩니다.

다중 case 레이블을 가진 switch 문 생성

이 단계에서는 C++ 에서 switch 문을 사용하여 단일 변수를 기반으로 여러 조건을 처리하는 방법을 배우게 됩니다. switch 문은 변수를 서로 다른 상수 값과 비교할 때 여러 if-else 문을 대체할 수 있습니다.

먼저, 프로젝트 디렉토리로 이동하여 새로운 C++ 파일을 생성합니다.

cd ~/project
touch switch_statement.cpp

WebIDE 에서 switch_statement.cpp 파일을 열고 다음 코드를 추가하여 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 문에 대한 주요 사항:

1. 실행할 여러 코드 블록 중 하나를 선택하는 데 사용됩니다.
2. 정수형 (int, char, enum) 과 함께 작동합니다.
3. 각 case는 가능한 값을 나타냅니다.
4. break 문은 다음 case 로의 fall-through 를 방지합니다.
5. default case 는 다른 case 와 일치하지 않는 값을 처리합니다.
6. 여러 case 가 동일한 코드 블록을 공유할 수 있습니다.

중요한 switch 문 규칙:

• 각 case는 break 또는 return으로 끝나야 합니다.
• case 는 상수 표현식이어야 합니다.
• 하나의 코드 블록만 실행됩니다.
• default case 는 선택 사항이지만 권장됩니다.

카운터 제어 for 루프 초기화

이 단계에서는 C++ 에서 카운터 제어 for 루프를 사용하는 방법을 배우게 됩니다. for 루프는 특정 횟수만큼 코드 블록을 실행하는 데 필수적이며, 알려진 반복 횟수로 반복이 필요한 작업에 완벽합니다.

먼저, 프로젝트 디렉토리로 이동하여 새로운 C++ 파일을 생성합니다.

cd ~/project
touch for_loops.cpp

WebIDE 에서 for_loops.cpp 파일을 열고 다음 코드를 추가하여 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 루프의 주요 구성 요소:

1. 초기화 (Initialization): int i = 1 - 카운터의 초기 값을 설정합니다.
2. 조건 (Condition): i <= 5 - 루프가 계속되어야 하는 시점을 정의합니다.
3. 증가/감소 (Increment/Decrement): i++ - 각 반복 후 카운터를 변경합니다.

중요한 for 루프 특징:

• 알려진 반복 횟수에 이상적입니다.
• 여러 초기화 문을 가질 수 있습니다.
• 각 반복에서 여러 변수를 수정할 수 있습니다.
• 루프 실행을 유연하게 제어합니다.

입구 제어 로직을 사용한 while 루프 생성

이 단계에서는 C++ 에서 while 루프를 사용하는 방법을 배우게 됩니다. while 루프는 지정된 조건이 참으로 유지되는 동안 코드 블록을 반복적으로 실행하는 진입 제어 루프입니다. 조건은 각 반복 전에 확인되므로 초기 조건이 거짓이면 루프가 전혀 실행되지 않을 수 있습니다.

먼저, 프로젝트 디렉토리로 이동하여 새로운 C++ 파일을 생성합니다.

cd ~/project
touch while_loops.cpp

WebIDE 에서 while_loops.cpp 파일을 열고 다음 코드를 추가하여 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 루프의 주요 특징:

1. 각 반복 전에 조건이 확인됩니다.
2. 초기 조건이 거짓이면 루프가 실행되지 않을 수 있습니다.
3. 루프 변수의 수동 증가/업데이트가 필요합니다.
4. 반복 횟수를 미리 알 수 없는 상황에 유용합니다.

중요한 while 루프 구성 요소:

• 루프 전 루프 변수의 초기화
• 루프 실행을 제어하는 조건
• 루프 본문 내 루프 변수의 업데이트

출구 제어 로직을 위한 do-while 루프 구현

이 단계에서는 C++ 에서 do-while 루프에 대해 배우게 됩니다. while 루프와 달리, do-while 루프는 종료 제어 루프입니다. 즉, 조건이 루프 본문을 실행한 후에 확인됩니다. 이는 초기 조건에 관계없이 루프 본문이 최소한 한 번은 실행되도록 보장합니다.

먼저, 프로젝트 디렉토리로 이동하여 새로운 C++ 파일을 생성합니다.

cd ~/project
touch do_while_loops.cpp

WebIDE 에서 do_while_loops.cpp 파일을 열고 다음 코드를 추가하여 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 루프의 주요 특징:

1. 조건은 루프 본문을 실행한 후에 확인됩니다.
2. 루프의 최소 한 번 실행을 보장합니다.
3. 입력 유효성 검사 및 게임에 유용합니다.
4. 구문은 끝에서 조건을 확인하여 while 루프와 다릅니다.

중요한 do-while 루프 구성 요소:

• do 키워드는 루프 본문을 시작합니다.
• 루프 본문은 항상 최소 한 번 실행됩니다.
• while 조건은 각 반복 후에 평가됩니다.
• 세미콜론 ;은 while 조건 뒤에 필요합니다.

break 문을 사용하여 루프 조기 종료

이 단계에서는 C++ 에서 break 문을 사용하여 루프를 조기에 종료하는 방법을 배우게 됩니다. break 문을 사용하면 루프를 즉시 종료하고 루프 다음의 첫 번째 문으로 제어를 전송할 수 있습니다.

먼저, 프로젝트 디렉토리로 이동하여 새로운 C++ 파일을 생성합니다.

cd ~/project
touch break_statement.cpp

WebIDE 에서 break_statement.cpp 파일을 열고 다음 코드를 추가하여 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 문의 주요 특징:

1. 가장 안쪽의 루프를 즉시 종료합니다.
2. 루프 다음의 첫 번째 문으로 제어를 전송합니다.
3. for, while, 및 do-while 루프에서 사용할 수 있습니다.
4. 조건에 따라 루프를 조기에 종료하는 데 유용합니다.

중요한 break 문 사용법:

• 특정 조건이 충족될 때 루프 종료
• 검색 알고리즘 구현
• 사용자 입력을 사용하여 대화형 프로그램 생성
• 불필요한 반복 방지

continue 문으로 루프 반복 건너뛰기

이 단계에서는 C++ 에서 continue 문을 사용하여 루프의 현재 반복을 건너뛰고 다음 반복으로 이동하는 방법을 배우게 됩니다. continue 문을 사용하면 특정 조건에 따라 루프의 일부를 선택적으로 건너뛸 수 있습니다.

먼저, 프로젝트 디렉토리로 이동하여 새로운 C++ 파일을 생성합니다.

cd ~/project
touch continue_statement.cpp

WebIDE 에서 continue_statement.cpp 파일을 열고 다음 코드를 추가하여 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 문의 주요 특징:

1. 현재 루프 반복의 나머지 부분을 건너뜁니다.
2. 루프의 다음 반복으로 제어를 전송합니다.
3. for, while, 및 do-while 루프에서 사용할 수 있습니다.
4. 필터링 또는 조건부 처리에 유용합니다.

중요한 continue 문 사용법:

• 조건에 따라 특정 반복 건너뛰기
• 루프에서 데이터 필터링
• 불필요한 계산 방지
• 루프 로직 단순화

행렬 연산을 위한 중첩 루프 생성

이 단계에서는 C++ 에서 2 차원 배열 (행렬) 에 대한 연산을 수행하기 위해 중첩 루프를 사용하는 방법을 배우게 됩니다. 중첩 루프를 사용하면 행렬의 행과 열을 반복하여 복잡한 데이터 조작 및 계산을 수행할 수 있습니다.

먼저, 프로젝트 디렉토리로 이동하여 새로운 C++ 파일을 생성합니다.

cd ~/project
touch nested_loops.cpp

WebIDE 에서 nested_loops.cpp 파일을 열고 다음 코드를 추가하여 중첩 루프를 사용하여 행렬 연산을 탐색합니다.

#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

중첩 루프의 주요 특징:

1. 내부 루프는 외부 루프의 각 반복에 대해 모든 반복을 완료합니다.
2. 다차원 배열 작업에 유용합니다.
3. 복잡한 패턴을 만들고 행렬 연산을 수행하는 데 사용할 수 있습니다.
4. 일반적으로 2 차원 배열 (행렬) 및 다차원 데이터 구조와 함께 사용됩니다.

중요한 중첩 루프 개념:

• 외부 루프는 내부 루프가 실행되는 횟수를 제어합니다.
• 각 루프에는 자체 카운터 변수가 있습니다.
• 행 및 열 기반 연산에 유용합니다.
• 패턴 생성, 계산 수행 및 데이터 조작에 사용할 수 있습니다.

무한 루프 방지 처리

이 단계에서는 적절한 루프 제어 메커니즘을 구현하여 C++ 에서 무한 루프를 방지하는 방법을 배우게 됩니다. 무한 루프는 루프의 조건이 결코 거짓이 되지 않아 프로그램이 무기한으로 실행될 때 발생합니다.

먼저, 프로젝트 디렉토리로 이동하여 새로운 C++ 파일을 생성합니다.

cd ~/project
touch infinite_loop_prevention.cpp

WebIDE 에서 infinite_loop_prevention.cpp 파일을 열고 다음 코드를 추가하여 무한 루프를 방지하기 위한 다양한 전략을 탐색합니다.

#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

무한 루프를 방지하기 위한 주요 전략:

1. 최대 반복 횟수 제한 설정
2. break 문을 사용하여 루프 종료
3. 입력 유효성 검사 구현
4. 루프 실행을 제어하기 위한 조건부 검사 추가
5. 사용자 제어 메커니즘 제공

중요한 무한 루프 방지 기술:

• 항상 루프 조건이 거짓이 될 수 있는지 확인합니다.
• 카운터 변수를 사용하여 반복 횟수를 제한합니다.
• 루프 내에 종료 조건을 구현합니다.
• 사용자 입력을 검증합니다.
• 필요한 경우 break를 사용하여 루프를 종료합니다.

요약

이 랩에서는 C++ 에서 단일 및 다중 분기 if-else 문, switch 문, 카운터 제어 for 루프, 진입 제어 while 루프, 종료 제어 do-while 루프 및 중첩 루프를 포함한 다양한 제어 흐름 구조를 구현하는 방법을 배웠습니다. 루프 실행을 제어하기 위해 break 및 continue 문을 사용하는 방법을 탐구하고, 무한 루프를 처리하는 기술을 배웠습니다. 이러한 제어 흐름 구조는 C++ 프로그래밍의 기본이며, 특정 조건에 따라 결정을 내리고 다른 코드 경로를 실행할 수 있는 더 복잡하고 동적인 프로그램을 작성할 수 있도록 해줍니다.

이 랩에서는 이러한 제어 흐름 구조의 실용적인 적용을 실습 코딩 연습을 통해 다루었으며, 이를 통해 사용법에 대한 더 깊은 이해를 개발하고 자체 C++ 프로젝트에서 효과적으로 적용할 수 있는 능력을 키울 수 있었습니다.