Control Flow: Sequencing and Selection

• Flow of control, or control flow, dictates the order of execution for statements, instructions, and function calls in an imperative program.
• Statements include expressions, which always return values.
• An example of a simple statement: x = x + 1.
• Control flow statements alter the order in which statements are executed.
• Categories of control flow statements:
  • Sequencing
  • Selection
  • Iteration
  • Unconditional branch

Sequencing

• A code block groups statements together.
• Structured programming executes statements sequentially.
• Sequencing represents the most basic control flow.
• Statements are executed in the order they appear in source code.
• After executing a statement, control flow moves to the next one.
• Code blocks are fundamental for grouping statements in control structures.

Selection

• Selection, or conditional, statements allow programs to make decisions, executing different code sections based on conditions.
• Selection statements include:
  • if statements
  • if-else statements
  • switch statements

if statements

• if statements execute a block of code only when a specified condition is true.
• Example in C++:

if (condition) {
    // Code to execute if condition is true
}

• The condition is a boolean expression.
• If the condition is true, the code block within the if statement executes.
• If the condition is false, the code block is skipped.

if-else statements

• if-else statements provide an alternative code block to execute if the if condition is false.
• Example in C++:

if (condition) {
    // Code to execute if condition is true
} else {
    // Code to execute if condition is false
}

• If the condition is true, the first block of code executes.
• If the condition is false, the second block (inside the else statement) is executed.

switch statements

• switch statements select among multiple code blocks based on a variable or expression's value.
• Example in C++:

switch (variable) {
    case value1:
        // Code to execute if variable == value1
        break;
    case value2:
        // Code to execute if variable == value2
        break;
    default:
        // Code to execute if variable doesn't match any case
}

• The switch statement evaluates the variable and compares it to case values.
• If a match is found, the code block for that case executes.
• The break statement exits the switch after a match.
• If no case matches, the default case executes, if provided.

Iteration

• Iteration statements, or loops, allow repeated code execution.
• Loops continue as long as a specified condition remains true.
• Iteration statements include:
  • for loops
  • while loops
  • do-while loops

for loops

• for loops repeat a code block a specific number of times.
• Example in C++:

for (initialization; condition; increment) {
    // Code to execute repeatedly
}

- Initialization executes before the loop starts.
- Condition is checked before each iteration; the loop continues if `true`.
- Increment executes after each iteration, often updating a counter.

while loops

• while loops execute a code block as long as a specified condition is true.
• Example in C++:

while (condition) {
    // Code to execute while condition is true
}

• The condition is checked before each iteration.
• If the condition is true, the code block executes; otherwise, the loop terminates.

do-while loops

• do-while loops execute a code block at least once before checking the condition.
• Example in C++:

do {
    // Code to execute at least once
} while (condition);

• The code block executes first, and then the condition is checked.
• If the condition is true, the loop continues; otherwise, it terminates.

Unconditional Branch

• Unconditional branch statements transfer control to another part of the program without any condition.
• These statements include:
  • goto statements
  • break statements
  • continue statements
  • return statements

goto statements

• goto statements transfer control to a labeled statement within the same function.
• Example in C++:

goto label;
// Some code
label:
// Code after the label

• goto statements can reduce code readability and maintainability, so they are generally not recommended in structured programming.
• The goto statement moves execution to the program point with the corresponding label.

break statements

• break statements are used inside loops or switch statements to exit the structure early.
• Inside a loop, break terminates the loop, transferring control to the next statement.

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break; // Exit the loop when i equals 5
    }
    // Some code
}

• Inside a switch statement, break prevents fall-through to the next case.

switch (variable) {
    case value1:
        // Code
        break;
    case value2:
        // Code
        break;
}

continue statements

• continue statements, used inside loops, skip the rest of the current iteration and proceed to the next iteration.
• Example in C++:

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        continue; // Skip the rest of the iteration when i equals 5
    }
    // Some code
}

• When continue is encountered, the remaining statements are skipped, and the loop goes to the next iteration.

return statements

• return statements exit a function, returning a value to the caller (if the function has a return type).
• Example in C++:

int add(int a, int b) {
    return a + b; // Return the sum of a and b
}

• The return statement terminates the function and passes the value back to the caller.
• For a void return type, return can be used without a value to simply exit the function.

void printMessage() {
    cout