Control Structures in C++

Control structures are programming constructs that allow you to control the flow of execution in a program. They enable you to make decisions, execute code repeatedly, and control program flow based on conditions. C++ provides three main types of control structures: sequential, selection, and iteration.

1. Sequential Control Structure

Sequential control is the default flow where statements are executed one after another in the order they appear in the program.

#include <iostream>
using namespace std;

int main() {
    int a = 10;          // First statement
    int b = 20;          // Second statement
    int sum = a + b;     // Third statement
    cout << sum << endl; // Fourth statement
    return 0;           // Fifth statement
}

In this example, the statements are executed in order from top to bottom.

2. Selection (Decision) Control Structures

Selection control structures allow your program to make decisions based on conditions. C++ provides several selection statements:

2.1 if Statement

The if statement executes a block of code if a specified condition is true.

Syntax:

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

Example:

int age = 20;

if (age >= 18) {
    cout << "You are eligible to vote." << endl;
}

2.2 if-else Statement

The if-else statement executes one block of code if a condition is true and another block if it’s false.

Syntax:

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

Example:

int number = 15;

if (number % 2 == 0) {
    cout << "The number is even." << endl;
} else {
    cout << "The number is odd." << endl;
}

2.3 if-else if-else Statement (if-else Ladder)

The if-else if-else ladder allows you to check multiple conditions sequentially.

Syntax:

if (condition1) {
    // code to execute if condition1 is true
} else if (condition2) {
    // code to execute if condition1 is false and condition2 is true
} else if (condition3) {
    // code to execute if condition1 and condition2 are false and condition3 is true
} else {
    // code to execute if all conditions are false
}

Example:

int score = 75;

if (score >= 90) {
    cout << "Grade: A" << endl;
} else if (score >= 80) {
    cout << "Grade: B" << endl;
} else if (score >= 70) {
    cout << "Grade: C" << endl;
} else if (score >= 60) {
    cout << "Grade: D" << endl;
} else {
    cout << "Grade: F" << endl;
}

2.4 Nested if Statements

You can place if statements inside other if or else blocks to create nested conditions.

Example:

int age = 25;
bool hasLicense = true;

if (age >= 18) {
    if (hasLicense) {
        cout << "You can drive a car." << endl;
    } else {
        cout << "You need to get a license first." << endl;
    }
} else {
    cout << "You are too young to drive." << endl;
}

2.5 switch Statement

The switch statement selects one of many code blocks to be executed based on the value of an expression.

Syntax:

switch (expression) {
    case value1:
        // code to execute if expression equals value1
        break;
    case value2:
        // code to execute if expression equals value2
        break;
    ...
    default:
        // code to execute if expression doesn't match any case
}

Example:

int day = 3;
string dayName;

switch (day) {
    case 1:
        dayName = "Monday";
        break;
    case 2:
        dayName = "Tuesday";
        break;
    case 3:
        dayName = "Wednesday";
        break;
    case 4:
        dayName = "Thursday";
        break;
    case 5:
        dayName = "Friday";
        break;
    case 6:
        dayName = "Saturday";
        break;
    case 7:
        dayName = "Sunday";
        break;
    default:
        dayName = "Invalid day";
}

cout << "Day " << day << " is " << dayName << endl;

Key Points about switch:

  1. The expression in switch must evaluate to an integral type (int, char, enum).
  2. The break statement is used to exit the switch block. Without it, execution would “fall through” to the next case.
  3. The default case is optional and executes if no case matches.
  4. Multiple cases can share the same code by omitting the break statement.

Example of fall-through:

char grade = 'B';

switch (grade) {
    case 'A':
        cout << "Excellent!" << endl;
        break;
    case 'B':  // Falls through to case 'C'
    case 'C':
        cout << "Well done!" << endl;
        break;
    case 'D':
        cout << "You passed." << endl;
        break;
    case 'F':
        cout << "Try again." << endl;
        break;
    default:
        cout << "Invalid grade." << endl;
}

2.6 Conditional Operator (Ternary Operator)

The conditional operator ? : provides a shorthand way to write simple if-else statements.

Syntax:

condition ? expression_if_true : expression_if_false

Example:

int a = 10, b = 20;
int max = (a > b) ? a : b;  // max will be 20

string status = (age >= 18) ? "Adult" : "Minor";

3. Iteration (Loop) Control Structures

Iteration control structures allow you to execute a block of code repeatedly as long as a condition is true or for a specific number of times.

3.1 while Loop

The while loop executes a block of code as long as a specified condition is true.

Syntax:

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

Example:

int count = 1;

while (count <= 5) {
    cout << count << " ";
    count++;
}
// Output: 1 2 3 4 5

Key characteristics of while loop:

  • The condition is checked before the loop body executes.
  • If the condition is initially false, the loop body never executes.
  • Useful when you don’t know in advance how many times the loop should run.

3.2 do-while Loop

The do-while loop is similar to the while loop, but it checks the condition after executing the loop body, ensuring the body executes at least once.

Syntax:

do {
    // code to execute
} while (condition);

Example:

int count = 1;

do {
    cout << count << " ";
    count++;
} while (count <= 5);
// Output: 1 2 3 4 5

Even if the condition is initially false, the loop body executes once:

int x = 10;

do {
    cout << "This will print once." << endl;
} while (x < 5);

3.3 for Loop

The for loop provides a concise way to write loop structures by combining initialization, condition, and increment/decrement in a single statement.

Syntax:

for (initialization; condition; update) {
    // code to execute while condition is true
}

Example:

for (int i = 1; i <= 5; i++) {
    cout << i << " ";
}
// Output: 1 2 3 4 5

The components of a for loop:

  1. Initialization: Executes once at the beginning (e.g., int i = 1)
  2. Condition: Checked before each iteration (e.g., i <= 5)
  3. Update: Executes after each iteration (e.g., i++)

All three components are optional:

// Infinite loop
for (;;) {
    // code to execute indefinitely
    // (need a break statement to exit)
}

You can use multiple variables in a for loop:

for (int i = 0, j = 10; i < j; i++, j--) {
    cout << "i = " << i << ", j = " << j << endl;
}

3.4 Range-based for Loop (C++11)

The range-based for loop simplifies iteration over elements in an array, container, or any sequence.

Syntax:

for (type variable : collection) {
    // code to execute for each element
}

Example:

int numbers[] = {1, 2, 3, 4, 5};

for (int num : numbers) {
    cout << num << " ";
}
// Output: 1 2 3 4 5

Using it with C++ standard library containers:

#include <vector>
vector<string> names = {"Alice", "Bob", "Charlie"};

for (const string& name : names) {
    cout << name << " ";
}
// Output: Alice Bob Charlie

Using auto for type deduction:

for (auto value : collection) {
    // code using value
}

Modifying elements using reference:

for (auto& value : collection) {
    value *= 2;  // Doubles each value in the collection
}

3.5. Nested Loops

You can place one loop inside another to create nested loops. This is useful for working with multi-dimensional data structures or generating complex patterns.

Example - Multiplication table:

for (int i = 1; i <= 5; i++) {
    for (int j = 1; j <= 5; j++) {
        cout << i * j << "\t";
    }
    cout << endl;
}

Output:

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

4. Jump Statements

Jump statements alter the flow of control by transferring execution to another part of the program.

4.1 break Statement

The break statement terminates the innermost enclosing loop or switch statement.

Examples:

In a loop:

for (int i = 1; i <= 10; i++) {
    if (i == 6) {
        break;  // Exit the loop when i equals 6
    }
    cout << i << " ";
}
// Output: 1 2 3 4 5

In a nested loop, break only exits the innermost loop:

for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
        if (i * j > 4) {
            break;  // Exits only the inner loop
        }
        cout << i * j << " ";
    }
    cout << endl;
}

Output:

1 2 3
2 4
3

4.2 continue Statement

The continue statement skips the remaining code in the current iteration of a loop and proceeds to the next iteration.

Example:

for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue;  // Skip even numbers
    }
    cout << i << " ";
}
// Output: 1 3 5 7 9

In a while or do-while loop, continue jumps back to the condition check:

int i = 0;
while (i < 10) {
    i++;
    if (i % 2 == 0) {
        continue;
    }
    cout << i << " ";
}
// Output: 1 3 5 7 9

4.3 goto Statement

The goto statement transfers control to a labeled statement within the same function.

Syntax:

goto label;
// ...
label: statement;

Example:

int i = 1;

start:
    if (i <= 5) {
        cout << i << " ";
        i++;
        goto start;  // Jump back to the label
    }
// Output: 1 2 3 4 5

Note: The goto statement is generally discouraged in modern C++ programming because it can make code harder to understand and maintain. It’s better to use structured control statements like loops and conditionals.

4.4 return Statement

The return statement exits the current function and returns control to the calling function. It can also return a value.

Example:

int max(int a, int b) {
    if (a > b) {
        return a;  // Return a and exit the function
    }
    return b;      // Return b and exit the function
}

int main() {
    cout << max(10, 20) << endl;  // Outputs: 20
    return 0;  // Return from main and end the program
}

5. Best Practices for Control Structures

  1. Use braces consistently: Even for single-statement blocks, using braces improves readability and prevents bugs when adding more statements later.

    // Good practice
if (condition) {
    statement;
}

// Risky practice
if (condition)
    statement;

  2. Avoid deep nesting: Excessive nesting of control structures makes code harder to read and maintain. Consider refactoring deeply nested code into separate functions.

  3. Choose the right loop: Select the appropriate loop type based on your needs:

    • Use for when you know the number of iterations in advance
    • Use while when you need to check a condition before entering the loop
    • Use do-while when you need to execute the loop at least once
    • Use range-based for when iterating over collections

  4. Be cautious with infinite loops: When creating intentional infinite loops, always ensure there’s a way to exit the loop (e.g., a break statement).

    while (true) {
    // Process data
    if (exitCondition) {
        break;
    }
}

  5. Limit the use of goto: Prefer structured control statements over goto. If you must use goto, restrict it to specific scenarios like error handling.

  6. Prefer switch over long if-else chains: For multi-way branching based on a single value, a switch statement is often more readable than a long chain of if-else statements.

  7. Keep loop bodies simple: If a loop body becomes too complex, consider extracting parts into separate functions.

  8. Be careful with loop variables: When using loop variables outside the loop, be aware of their final values.

    int i;
for (i = 0; i < 10; i++) {
    // ...
}
cout << "Final value of i: " << i << endl;  // i is 10 here

  9. Use early returns for guard clauses: For functions with preconditions, it’s often clearer to return early if the conditions aren’t met.

    bool processData(const Data* data) {
    if (data == nullptr) {
        return false;  // Early return for invalid input
    }
    
    // Process valid data...
    return true;
}

  10. Use the conditional operator for simple cases: The ternary operator can make simple if-else assignments more concise.

    // Instead of
string status;
if (age >= 18) {
    status = "Adult";
} else {
    status = "Minor";
}

// Use
string status = (age >= 18) ? "Adult" : "Minor";

Understanding control structures is fundamental to programming in C++. These constructs allow you to implement complex logic and algorithms by controlling the flow of your program’s execution.