CMS 708 · Structured Programming

The same task, both ways · the exam's favourite pairing

UNSTRUCTURED · using goto
#include <iostream>
using namespace std;

int main() {
    int x = 0;
start:
    cout << "Enter a number (0 to quit): ";
    cin >> x;
    if (x != 0) {
        cout << "You entered: " << x << endl;
        goto start;          // jumps back to start
    }
    cout << "Program ended." << endl;
    return 0;
}

STRUCTURED · using a do-while loop
#include <iostream>
using namespace std;

int main() {
    int x;
    do {
        cout << "Enter a number (0 to quit): ";
        cin >> x;
        if (x != 0) {
            cout << "You entered: " << x << endl;
        }
    } while (x != 0);
    cout << "Program ended." << endl;
    return 0;
}

The sentence that earns the mark: both programs do the same thing, but the goto version makes the flow harder to follow, and as the program grows debugging becomes chaotic, while the do-while gives a clear, predictable structure that is easier to read, maintain and extend.

Modularity divides a program into independent units, each performing a specific task, developed, tested and reused independently. This reduces redundancy and enhances collaboration, since different programmers can work on separate modules without interfering with each other.

Readability ensures code is understandable to others, through meaningful variable names, consistent indentation and clear documentation. It avoids unnecessary complexity and follows logical patterns that mirror human reasoning.

Together they make programming a disciplined activity rather than a chaotic one, transforming code into a form of communication · not just between the programmer and the computer, but between programmers themselves.

Why it matters in practice: teams work on large projects like banking systems, hospital management software or video games. Without modularity the codebase becomes overwhelming.

WITHOUT modularity · everything crammed into main()
int main() {
    int a, b;
    cout << "Enter two numbers: ";
    cin  >> a >> b;
    cout << "Sum: "        << a + b << endl;
    cout << "Difference: " << a - b << endl;
    cout << "Product: "    << a * b << endl;
    cout << "Quotient: "   << a / b << endl;
    return 0;
}   // to reuse these operations we must rewrite them

WITH modularity · one function per operation
int    add(int x, int y)      { return x + y; }
int    subtract(int x, int y) { return x - y; }
int    multiply(int x, int y) { return x * y; }
double divide(int x, int y)   { return (double)x / y; }

int main() {
    int a, b;
    cout << "Enter two numbers: ";
    cin  >> a >> b;
    cout << "Sum: "        << add(a, b)      << endl;
    cout << "Difference: " << subtract(a, b) << endl;
    cout << "Product: "    << multiply(a, b) << endl;
    cout << "Quotient: "   << divide(a, b)   << endl;
    return 0;
}

Note the cast in divide: (double)x / y. Without it, 10 / 3 is integer division and gives 3, not 3.333. This is a classic exam trap.

Syntax · the rules that are always worth a mark

• Every program begins with a main() function, which acts as the entry point.
• Statements end with semicolons.
• Blocks are enclosed in curly braces { }.
• Variables must be declared with a data type before use · C++ is strongly typed.
• #include brings in a library; using namespace std; lets you write cout instead of std::cout.

The six data types in the notes

#include <iostream>
#include <string>
using namespace std;

int main() {
    int    age        = 20;        // integer
    double salary     = 45000;     // floating-point
    char   grade      = 'A';       // character
    bool   isEmployed = true;      // boolean
    string name       = "Ada";     // string

    cout << "Name: " << name
         << ", Age: " << age << endl;
    return 0;
}

Input and output

The iostream library provides cin for input and cout for output. These make programs dynamic, letting users supply data in real time instead of hardcoding values.

#include <iostream>
using namespace std;

int main() {
    int number;
    cout << "Enter a number: ";      // output prompt
    cin  >> number;                  // input from user
    cout << "You entered: " << number << endl;
    return 0;
}

Direction of the arrows: cout << sends data out to the screen; cin >> brings data in from the keyboard into the variable. Writing them the wrong way round is the single most common syntax error on this paper. endl ends the line.

The five operator families

#include <iostream>
#include <string>
using namespace std;

int main() {
    string name;
    double grossSalary, taxRate, netSalary;

    cout << "Enter employee name: ";
    cin  >> name;
    cout << "Enter gross salary: ";
    cin  >> grossSalary;
    cout << "Enter tax rate (%): ";
    cin  >> taxRate;

    netSalary = grossSalary - (grossSalary * taxRate / 100);

    cout << "\nEmployee: "   << name      << endl;
    cout << "Net Salary: "   << netSalary << endl;
    return 0;
}

This one program integrates variables, data types, input/output and operators · which is exactly what a "write a program that…" question is testing. Learn its shape and you can adapt it to almost any arithmetic scenario the paper sets:

1. Headers and using namespace std;
2. Declare every variable you will need, with the right type
3. Prompt, then read, one value at a time
4. Do the calculation in a single clearly-written statement
5. Print the result with a label
6. return 0;

Selection · if and switch

if-else · grading system
int score;
cout << "Enter student score: ";
cin  >> score;

if      (score >= 70) cout << "Grade: A" << endl;
else if (score >= 60) cout << "Grade: B" << endl;
else if (score >= 50) cout << "Grade: C" << endl;
else                  cout << "Grade: F" << endl;

switch · menu selection
int choice;
cout << "Menu:\n1. Add\n2. Subtract\n"
     << "3. Multiply\n4. Divide\n";
cout << "Enter choice: ";
cin  >> choice;

switch (choice) {
    case 1: cout << "You chose Addition."       << endl; break;
    case 2: cout << "You chose Subtraction."    << endl; break;
    case 3: cout << "You chose Multiplication." << endl; break;
    case 4: cout << "You chose Division."       << endl; break;
    default: cout << "Invalid choice."          << endl;
}

Iteration · the three loops

for · print numbers 1 to 5
for (int i = 1; i <= 5; i++) {
    cout << "Number: " << i << endl;
}

while · password check
string password;
cout << "Enter password: ";
cin  >> password;

while (password != "secret") {
    cout << "Wrong password! Try again: ";
    cin  >> password;
}
cout << "Access granted!" << endl;

do-while · repeated input
int num;
do {
    cout << "Enter a positive number (0 to quit): ";
    cin  >> num;
    if (num > 0) cout << "You entered: " << num << endl;
} while (num != 0);

The for header has three parts separated by semicolons: for (initialisation; condition; update). Leave out the update and the loop never ends.

Control structures can be combined or nested to handle complex logic · a loop may contain an if, or an if may contain another loop.

Nested for · multiplication table
for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
        cout << i << " x " << j
             << " = " << i * j << endl;
    }
    cout << endl;      // blank line between tables
}

Trace it: the outer loop runs 3 times; for each of those the inner loop runs 3 times, so the body executes 3 × 3 = 9 times. That multiplication is exactly the reasoning a "how many lines does this print?" question wants.

Operators inside a condition · voting eligibility
#include <iostream>
using namespace std;

int main() {
    int  age;
    bool hasID;

    cout << "Enter age: ";
    cin  >> age;
    cout << "Do you have an ID? (1 for yes, 0 for no): ";
    cin  >> hasID;

    if (age >= 18 && hasID) {
        cout << "You are eligible to vote." << endl;
    } else {
        cout << "You are not eligible to vote." << endl;
    }
    return 0;
}

Relational operators produce a bool, so they can be combined with &&, || and !. Note that hasID is already a bool, so && hasID needs no == true.

Anatomy of a function

double area(double length, double width) {
//  ↑        ↑     ↑
//  return   name  parameter list
    return length * width;
}

int main() {
    double l = 5.0, w = 3.0;
    cout << "Area: " << area(l, w) << endl;   // invocation
    return 0;
}

A function must be defined with a return type, a name and parameters (if any); once defined it can be invoked from main() or another function. Here area() is defined once and reused, which is modularity in one line.

Use void as the return type when the function returns nothing, and then write no return value.

Scope and lifetime

#include <iostream>
using namespace std;

int globalVar = 100;              // global variable

void showLocal() {
    int localVar = 50;            // local variable
    cout << "Local variable: "  << localVar  << endl;
    cout << "Global variable: " << globalVar << endl;
}

int main() {
    showLocal();
    cout << "Global in main: " << globalVar << endl;
    // cout << localVar;   // ERROR: not accessible here
    return 0;
}

Scope = where a variable can be accessed. Lifetime = how long it exists in memory. Local variables exist only while the function runs; global variables exist for the entire program execution. The commented-out line is the exam's favourite illustration · say why it fails.

Parameter passing · the guaranteed comparison

BY VALUE · a copy is passed
void incrementByValue(int x) {
    x++;
    cout << "Inside function: " << x << endl;
}

int main() {
    int num = 10;
    incrementByValue(num);
    cout << "Outside function: " << num << endl;
    return 0;
}

OUTPUT:   Inside function: 11
          Outside function: 10   ← original unchanged

BY REFERENCE · the actual variable is passed
void incrementByReference(int &x) {     // note the &
    x++;
    cout << "Inside function: " << x << endl;
}

int main() {
    int num = 10;
    incrementByReference(num);
    cout << "Outside function: " << num << endl;
    return 0;
}

OUTPUT:   Inside function: 11
          Outside function: 11   ← original modified

#include <iostream>
using namespace std;

int factorial(int n) {
    if (n == 0) return 1;                 // base case
    else        return n * factorial(n - 1);  // recursive call
}

int main() {
    int num = 5;
    cout << "Factorial of " << num
         << " is " << factorial(num) << endl;
    return 0;
}

Recursion occurs when a function calls itself. It suits problems that break into smaller, similar sub-problems · factorial, Fibonacci. Every recursion needs a base case that stops it; the notes warn that recursion must be used carefully to avoid infinite loops or excessive memory usage.

Trace it · factorial(5)

factorial(5) = 5 * factorial(4)
factorial(4) = 4 * factorial(3)
factorial(3) = 3 * factorial(2)
factorial(2) = 2 * factorial(1)
factorial(1) = 1 * factorial(0)
factorial(0) = 1                ← base case, unwinding starts

  = 1 * 1  = 1
  = 2 * 1  = 2
  = 3 * 2  = 6
  = 4 * 6  = 24
  = 5 * 24 = 120

Write the trace out like this in the exam · a "show how the recursion evaluates" question is asking for exactly these two columns: the winding down to the base case and the unwinding back up.

Top-down design

Starts with the big picture and progressively breaks it down. Define the overall problem, divide it into sub-problems, implement each as a module. It emphasizes stepwise refinement.

Analogy: building a house · the architect first designs the overall structure (rooms, floors, layout), then each part is broken down into plumbing, wiring, roofing and painting. Overall design first, then the details.

// High-level function
void manageStudent() {
    cout << "Managing student records..." << endl;
    // Refined later into smaller tasks
    cout << "1. Add student\n"
         << "2. Delete student\n"
         << "3. View student\n";
}

int main() {
    manageStudent();     // start with the big picture
    return 0;
}

The broad task "manage student records" is later refined into addStudent(), deleteStudent() and viewStudent().

Bottom-up design

Takes the opposite approach: start with the smallest building blocks and gradually integrate them into larger systems. Implement reusable components first, then combine them. It emphasizes reusability.

Analogy: assembling a car · engineers first design the engine, tyres and seats; once these modules are ready they are integrated into the complete car. Details first, then the overall system.

// Small building blocks
double add(double a, double b)      { return a + b; }
double multiply(double a, double b) { return a * b; }

// Larger system built from those modules
void calculate() {
    double x = 4, y = 2;
    cout << "Sum: "     << add(x, y)      << endl;
    cout << "Product: " << multiply(x, y) << endl;
}

int main() {
    calculate();     // integrates smaller modules
    return 0;
}

1. Omitting #include <iostream> or using namespace std;. Write them every single time, and <string> whenever you use string.
2. Forgetting return 0; at the end of main().
3. Writing cin << or cout >>. Output goes out with <<, input comes in with >>.
4. Using = where == is meant inside an if.
5. Missing break; in a switch · every case falls through to the next.
6. Integer division: 10 / 3 gives 3. Cast to double when a decimal is wanted.

7. A loop with no update statement, so it never terminates.
8. A recursive function with no base case · infinite recursion and a crash.
9. Forgetting the & when the question says "pass by reference" · the function then silently changes nothing.
10. Using a local variable outside its function and expecting it to compile.
11. Confusing 'A' (char, single quotes) with "A" (string, double quotes).
12. Writing flat, unindented code. Readability is an examinable topic on this course · losing marks for unreadable code in a structured-programming exam is avoidable.