Chapter 6 – Control Structures (C++)

Control Structures – General Overview

  • A C++ program is rarely a single linear sequence; instead it needs to
    • Repeat certain instructions (iteration)
    • Choose between alternative paths (selection / decision-making)
  • Constructs that provide these capabilities are collectively called control structures.
  • Every control structure ultimately manipulates the program counter (the instruction pointer) so that execution jumps forward, backward, or conditionally.
  • Introduction of control structures brings a new syntactic unit: the compound statement / block.

Compound Statements (Blocks)

  • Definition: A block is a group of C++ statements treated as one.
    • Written inside braces {}.
    • Each inner statement ends with a semicolon ; as usual.
    • Example syntax:
      cpp { statement1; statement2; statement3; }
  • Usage rules:
    • Wherever a single statement is allowed syntactically, a block can be substituted.
    • If only one instruction should run, braces are optional; if many, braces are mandatory.
  • Practical implication: Always consider braces for clarity, even for single-line bodies, to avoid logical errors when adding lines later (industry best practice).

Conditional Structure: if

  • Purpose: Execute a statement / block only if a boolean condition evaluates to true.
  • Syntax:
  if (condition)
      statement;      // may be a single instruction or a block
  • Flow (high-level algorithm):
    1. Evaluate condition.
    2. If true → run statement.
    3. Else → skip statement and continue after the if.
  • Simple example:
  if (x == 100)
      cout << "x is 100";
  • Multi-statement body example (using a block):
  if (x == 100) {
      cout << "x is ";
      cout << x;
  }
  • Complete applied program (division guard):
  #include <iostream>
  using namespace std;

  int main() {
      int dividend, divisor;
      cout << "Please enter two integers to divide:";
      cin >> dividend >> divisor;

      if (divisor != 0)
          cout << dividend << "/" << divisor << " = "
               << dividend / divisor << '\n';
      return 0;
  }
  • Demonstrates guarding against divide-by-zero error; if divisor \neq 0 the division is executed.
    • Nested if: An if inside another if to create hierarchical checks.
  if (value >= 0)
      if (value <= 10)
          cout << "In range";
  cout << "Done\n";
  • Logic: Only prints In range when 0 \leq value \leq 10.

Conditional Structure: if … else

  • Allows one action on true branch and an alternative on false branch.
  • Syntax:
  if (condition)
      statement1;   // executes when condition true
  else
      statement2;   // executes when condition false
  • Example:
  if (x == 100)
      cout << "x is 100";
  else
      cout << "x is not 100";
  • Multi-statement bodies require blocks.
  • Extended program (revisited division):
  if (divisor != 0) {
      cout << dividend << "/" << divisor << " = "
           << dividend / divisor << '\n';
  } else {
      cout << "Division by zero is not allowed\n";
  }

Conditional Structure: Nested / Cascaded if … else if … else

  • Purpose: Check multiple mutually exclusive conditions in sequence.
  • Generic syntax:
  if (cond1)
      stmt1;
  else if (cond2)
      stmt2;
  ...
  else
      stmtN;
  • Multi-category sign example:
  if (x > 0)
      cout << "x is positive";
  else if (x < 0)
      cout << "x is negative";
  else
      cout << "x is 0";
  • Full program translating integers 0 to 5 into words:
  if (value < 0)          cout << "Too small";
  else if (value == 0)    cout << "zero";
  else if (value == 1)    cout << "one";
  else if (value == 2)    cout << "two";
  else if (value == 3)    cout << "three";
  else if (value == 4)    cout << "four";
  else if (value == 5)    cout << "five";
  else                    cout << "Too large";

Iteration Structures (Loops) – Overview

  • A loop repeats a statement / block while or until a condition holds.
  • Motivation: Avoid code duplication; central for algorithms such as searching, sorting, numerical methods.
  • C++ provides three native loop constructs, each best suited for particular scenarios:
    1. for loop – counter-controlled, known iteration count.
    2. while loop – condition-controlled, unknown/variable count.
    3. do … while loop – post-test version, guarantees at least one execution.

for Loop

  • Syntax: \texttt{for (initialization; condition; update) statement;}
  • Sequence:
    1. Execute initialization once.
    2. Check condition. If false → exit loop.
    3. Execute statement (body).
    4. Execute update.
    5. Repeat from step 2.
  • Countdown example:
  for (int n = 10; n > 0; n--) {
      cout << n << ", ";
  }
  cout << "END!";
  • Output: 10,\ 9,\ 8,\ 7,\ 6,\ 5,\ 4,\ 3,\ 2,\ 1,\ END!
    • Omitted fields: Any of the three fields may be empty but semicolons remain.
  • Example: for (; n < 10; ) (no init, no update).

while Loop

  • Syntax: ```cpp
    while (expression)
    statement;
- Semantics: Entry-controlled; body executes **only if** expression is true.
- Custom countdown program:

cpp
int n;
cin >> n;
while (n > 0) {
cout << n << ", ";
--n; // crucial to avoid infinite loop
}
cout << "DONE!";

- Vital design note: Ensure something inside the loop eventually makes the condition false.

## `do … while` Loop
- Syntax:

cpp
do
statement;
while (condition);

- Semantics: Exit-controlled; body runs **at least once**.
- Echo program:

cpp
unsigned long n;
do {
cout << "Enter number (0 to end): "; cin >> n;
cout << "You entered: " << n << "\n";
} while (n != 0);

- Use-case guideline: Best when the termination condition depends on body interaction (e.g., reading user input inside the loop).

# Jump Statements
- Purpose: Alter the normal sequential flow instantly.
- Four in C++: `break`, `continue`, `return`, `goto`.

## `break`
- Immediately exits **innermost** loop or `switch`.
- Early-abort countdown:

cpp
for (int n = 10; n > 0; n--) {
cout << n << ", ";
if (n == 3) {
cout << "countdown aborted!";
break;
}
}

- Practical application: Emergency termination, searching until found, menu exit.

## `continue`
- Skips remaining body statements **only for the current iteration**, proceeds with next.
- Skipping 5 in countdown:

cpp
for (int n = 10; n > 0; n--) {
if (n == 5) continue; // jump to next iteration
cout << n << ", ";
}
cout << "DONE!";

## `goto`
- Unconditional jump to a **label** within same function.
- Example:

cpp
int n = 10;
loop:
cout << n << ", "; if (--n > 0) goto loop;
cout << "DONE!";

- Warnings / best practice:
  - Breaks structured programming;
  - Can create *spaghetti code*; avoid unless interfacing with low-level constructs or generated code.

## `return`
- Immediately exits the **current function**, optionally providing a return value.
  - In `main`, `return 0;` conventionally signals normal termination.

## `exit()` Function
- Prototype: `void exit(int exitcode);` from `<cstdlib>`.
- Terminates **entire** program, bypassing stack unwinding.
- Use exit\,(0) for normal termination; non-zero for error signalling.
- Distinction: `exit` executes static object destructors and `atexit` handlers, whereas some low-level aborts do not.

# Selective Structure: `switch`
- Designed for multi-way branching based on **integral** constant values (chars, ints, enums).
- Syntax skeleton:

cpp
switch (expression) {
case constant1:
statements1;
break;
case constant2:
statements2;
break;
…
default:
default_statements;
}

- Operational steps:
  1. Evaluate expression once.
  2. Compare with each `case` label in order.
  3. Jump into first matching label; execute downward until `break` or end of `switch`.
- Equivalence example (shows relation to `if-else if` chain):

cpp
switch (x) {
case 1: cout << "x is 1"; break;
case 2: cout << "x is 2"; break;
default: cout << "value of x unknown";
}
`` is semantically identical to nestedif/else if` shown earlier.

  • Fall-through behavior:
    • Omitting break lets execution continue into subsequent cases.
    • Allows grouping of labels:
      cpp switch (x) { case 1: case 2: case 3: cout << "x is 1, 2 or 3"; break; default: cout << "x is not 1, 2 nor 3"; }
  • Limitations:
    • case labels must be compile-time constants – no variables, no ranges.
    • For ranges or complex predicates, revert to if / else if.

Practical, Philosophical & Ethical Notes

  • Safety & correctness: Guarding against divide-by-zero, infinite loops, and other runtime errors is both a practical and ethical imperative (prevents crashes, data loss).
  • Maintainability: Using structured constructs (for, while, switch) rather than goto promotes readable, verifiable code – aligning with professional standards and collaborative development norms.
  • Resource considerations: Infinite loops or forgotten break statements can hog CPU cycles; responsible coding conserves shared computational resources.
  • User experience: Clear prompts and graceful exits (exit(0), informative error messages) respect users’ time and trust.
  • Historical context: Early languages relied heavily on goto; modern best practice ("structured programming" movement by Dijkstra) discourages it – foundational principle for subsequent object-oriented paradigms.

Quick Reference (Cheat Sheet)

  • \texttt{if}\,(cond) → single-branch decision
  • \texttt{if}\,(cond) … \texttt{else} → dual-branch decision
  • \texttt{if}\,…\texttt{else if}\,…\texttt{else} → multi-branch decision
  • \texttt{switch (expr)} → constant multi-branch selection, uses \texttt{case} labels & \texttt{break}
  • \texttt{for (init; cond; upd)} → counter loop
  • \texttt{while (cond)} → pre-test loop
  • \texttt{do}\,…\texttt{while (cond);} → post-test loop (executes at least once)
  • \texttt{break} → terminate loop / switch
  • \texttt{continue} → skip to next iteration
  • \texttt{return [value];} → exit function
  • \texttt{goto label;} → unconditional jump (avoid)
  • \texttt{exit(code);} → terminate program immediately (from )

Connections to Earlier / Foundational Material

  • Relies on Boolean logic (true / false) previously introduced in expressions chapter.
  • Uses operators such as ==, !=, >, < covered in relational-operator lecture.
  • Loop counters and conditions typically utilize variables, assignment, and arithmetic operations from basic C++ syntax lessons.

Real-World Relevance & Examples

  • Input validation (e.g., checking divisor \neq 0) mirrors production systems preventing crashes.
  • Menus in console apps often implemented with switch.
  • Sensor polling loops in embedded systems often require while(true) with internal break upon condition.
  • Game loops commonly exploit while for main update cycle, combined with continue for frame-skipping logic.

Common Pitfalls & Best Practices

  • Forgetting braces in nested if structures → dangling else problem.
  • Off-by-one errors in loop bounds (e.g., last iteration executed 10 times instead of 9).
  • Infinite loops due to non-mutated condition variable.
  • Neglecting break in switch causing unintended fall-through.
  • Prefer pre-increment/ decrement (++i) where semantics allow to potentially optimize.
  • Consider using range-based for in modern C++ for container iteration.

Formulas & Symbolic Reminders

  • Loop counter update: n \leftarrow n - 1 in countdown examples.
  • Guard condition pattern: \text{while}\,(condition) where condition → false eventually.
  • Division guard: divisor \neq 0 before evaluating \dfrac{dividend}{divisor}.

Summary

  • Control structures empower programs to make decisions and perform repetition, forming the backbone of algorithmic logic in C++.
  • Mastery involves understanding syntax, flow of control, and the nuanced differences between constructs so the most expressive, safe, and efficient tool is chosen for each task.