Programming 622 Study Hub

Prototype, Call, Definition

A function prototype tells the compiler the function name, return type, and parameter list before the function is called.

double calculateFine(int daysLate);   // prototype
void printReceipt(string name, double fine);

int main()
{
    int daysLate = 3;
    double fine;

    fine = calculateFine(daysLate);    // call
    printReceipt("Maya", fine);        // call
    return 0;
}

double calculateFine(int daysLate)    // definition
{
    double fine;

    fine = daysLate * 2.50;
    return fine;
}

Overloading and Defaults

Function overloading means using the same function name with different formal parameter lists. Constructor overloading uses the same idea inside a class.

void display(int mark);
void display(double average);
void display(string name, int mark = 0);

class Student {
public:
    Student();
    Student(string n);
    Student(string n, int m);
};

Stream Classes

Typical Read Pattern

#include <fstream>
using namespace std;

ifstream inFile;
int mark;
int total = 0;

inFile.open("marks.txt");

if (!inFile) {
    cout << "File could not open";
} else {
    while (inFile >> mark) {
        total += mark;
    }
}

inFile.close();

try, throw, catch

• try contains code that may cause a runtime problem.
• throw sends an exception value when the problem is detected.
• catch receives and handles the thrown value.

try {
    if (daysLate < 0) {
        throw daysLate;
    }

    fine = calculateFine(daysLate);
}
catch (int value) {
    cout << "Invalid days: " << value;
}

Common Mistakes

• A catch block only runs if something is thrown.
• Code after throw inside the same block is skipped.
• Exception handling does not fix bad logic; it handles exceptional cases.

Login Loop

A do-while loop is useful when the user must be prompted at least once.

do {
    cout << "Enter password: ";
    cin >> password;
} while (password != "admin");

Menu Loop

do {
    cout << "1. Add\\n2. Print\\n0. Exit\\n";
    cin >> choice;

    switch (choice) {
    case 1:
        addRecord();
        break;
    case 2:
        printRecords();
        break;
    case 0:
        cout << "Goodbye";
        break;
    default:
        cout << "Invalid choice";
    }
} while (choice != 0);

Abstract Base Class

class Student {
protected:
    string name;
public:
    Student(string n)
    {
        name = n;
    }

    virtual ~Student() {}
    virtual void print() const = 0;
};

The = 0 makes print() pure virtual. The base class becomes abstract, so you cannot create plain Student objects.

• The base class stores common data, such as name.
• protected lets derived classes use the member while still hiding it from the rest of the program.
• The virtual destructor helps clean up correctly when deleting through a base-class pointer.

Derived Classes and Overriding

class FullTimeStudent : public Student {
private:
    double tuition;
public:
    FullTimeStudent(string n, double t)
        : Student(n)
    {
        tuition = t;
    }

    void print() const override {
        cout << name << " " << tuition;
    }
};

• : public Student means FullTimeStudent is a kind of Student.
• : Student(n) calls the base-class constructor before the derived constructor body runs.
• tuition = t; is the more foundational way to assign the derived class's own data inside the constructor body.
• override confirms that this function replaces a virtual function from the base class.

The Colon in Inheritance

In C++, the colon is required when one class inherits from another class. There is no simpler replacement for the inheritance line itself.

class FullTimeStudent : public Student
{
    // FullTimeStudent inherits from Student
};

• : public Student means FullTimeStudent is a type of Student.
• The word public keeps the base class's public members public in the derived class.
• For exam writing, read the colon as "inherits from".

The Tilde in Destructors

A destructor is a special member function that runs when an object is destroyed. It has the same name as the class, but starts with ~.

class Student {
public:
    virtual ~Student()
    {
        // cleanup code would go here
    }
};

• ~Student() means "destructor for Student".
• A destructor has no return type, not even void.
• Use virtual on a base-class destructor when derived objects may be deleted through a base-class pointer.
• If there is no special cleanup, the destructor body can be empty.

2D Array Traversal

int votes[2][3] = {{12, 8, 15}, {9, 17, 11}};
int* p;
p = &votes[0][0];

for (int i = 0; i < 6; i++) {
    cout << *(p + i) << " ";
}

A two-dimensional array is stored row by row in memory. The pointer starts at the first element, then p + i moves to the next integer position.

Maximum and Total Votes

int maximum(int* p, int size)
{
    int maxValue = *p;
    for (int i = 1; i < size; i++) {
        if (*(p + i) > maxValue) {
            maxValue = *(p + i);
        }
    }
    return maxValue;
}

int totalVotes(int* p, int size)
{
    int total = 0;
    for (int i = 0; i < size; i++) {
        total += *(p + i);
    }
    return total;
}

• *p means "the value at the address currently stored in p".
• *(p + i) means "move i elements forward, then read the value there".
• The size argument protects the function from reading past the end of the array.

Why Pointer Cleanup Is Necessary

new reserves memory while the program is running. That memory remains reserved until it is released with delete, even if the pointer variable goes out of scope.

The Basic Cleanup Pattern

Student* student;
student = new FullTimeStudent("Asha", 12000);

student->print();

delete student;       // destroy object and release memory
student = nullptr;    // pointer now points to nothing

1. Use the dynamically allocated object.
2. Call delete once when the object is no longer needed.
3. Assign nullptr if the pointer remains in scope.

delete vs delete[]

int* marks;
marks = new int[5];

// use marks[0] to marks[4]

delete[] marks;
marks = nullptr;

When Not to Use delete

Only delete memory that your program obtained with new. Normal local variables and fixed arrays are cleaned up automatically.

int mark = 80;
int marks[5];
Student student("Asha");

// Do not delete these.

int* p;
p = &mark;              // points to existing variable

// Do not delete p.

• Do not delete a stack/local variable.
• Do not delete a pointer that only borrows another object's address.
• Do not delete the same allocation through two different pointers.

Understanding nullptr

nullptr is a special value meaning that a pointer deliberately points to no object or memory location.

Student* student;
student = nullptr;

if (student != nullptr) {
    student->print();
}

delete student;        // safe: deleting nullptr does nothing

• Initialize a pointer to nullptr when it does not yet have an address.
• Test against nullptr before dereferencing an optional pointer.
• Reset a pointer to nullptr after deletion when it remains available for later use.

Unsafe and Safe Comparison

// Unsafe
Student* p;
p = new FullTimeStudent("Asha", 12000);
delete p;
p->print();             // error: dangling pointer

// Safer
p = new FullTimeStudent("Asha", 12000);
delete p;
p = nullptr;

if (p != nullptr) {
    p->print();
}

Core Ideas

• A programming paradigm is an approach to solving a problem using a programming language.
• Imperative programming focuses on how steps execute.
• Declarative programming focuses on what result is wanted.
• Structured design divides a problem into smaller subproblems.
• Object-oriented design identifies objects, their data, and their operations.

C++ Processing Steps

1. Editor: create and save the source code as a .cpp file.
2. Preprocessor: handles lines beginning with #.
3. Compiler: checks syntax and translates source to object code.
4. Linker: combines object code with library code.
5. Loader: places the executable in memory.
6. Execution: the program runs.

Program Structure

#include <iostream>
using namespace std;

int main()
{
    cout << "Hello" << endl;
    return 0;
}

• #include <iostream> enables input and output.
• int main() is the starting point.
• Braces group statements into a block.
• return 0; indicates normal program completion.

Tokens, Types, and Operators

Selection

• Sequence executes statements in order.
• Selection chooses a path using if, if...else, or switch.
• switch works well when one expression is compared with constant case labels.
• Use break to prevent fall-through between cases.

Repetition

Function Basics

• A function is a named block that performs a task.
• A value-returning function sends a result back with return.
• A void function performs an action without returning a value.
• Formal parameters appear in the function heading.
• Actual parameters are the values passed during the call.

Exam Function Pattern

double calculateFine(int daysLate)
{
    double fine;

    fine = daysLate * 2.50;
    return fine;
}

void printReceipt(string name, double fine)
{
    cout << "Name: " << name << endl;
    cout << "Fine: R" << fine << endl;
}

Arrays and Strings

• An array stores multiple values of the same type under one name.
• Array indexes start at 0.
• A one-dimensional array is list-like.
• A two-dimensional array uses rows and columns.
• Arrays passed to functions behave like address-based data.

Pointer Essentials

Declaring, Filling, and Printing Arrays

The size of a fixed array must be known before it is used. Most exam code passes the array and its size together.

const int SIZE = 5;
int marks[SIZE];

for (int i = 0; i < SIZE; i++) {
    cout << "Enter mark " << i + 1 << ": ";
    cin >> marks[i];
}

for (int i = 0; i < SIZE; i++) {
    cout << marks[i] << " ";
}

Passing Arrays to Functions

When an array is passed to a function, the function receives access to the original array data. That is why changes inside the function can affect the original elements.

void printArray(const int values[], int size)
{
    for (int i = 0; i < size; i++) {
        cout << values[i] << " ";
    }
}

void increaseAll(int values[], int size)
{
    for (int i = 0; i < size; i++) {
        values[i] = values[i] + 1;
    }
}

Common Array Functions

Sum, Average, and Maximum

int sumArray(const int values[], int size)
{
    int total = 0;
    for (int i = 0; i < size; i++) {
        total += values[i];
    }
    return total;
}

double averageArray(const int values[], int size)
{
    int total;
    double average;

    total = sumArray(values, size);
    average = total / static_cast<double>(size);

    return average;
}

int findMax(const int values[], int size)
{
    int maxValue = values[0];
    for (int i = 1; i < size; i++) {
        if (values[i] > maxValue) {
            maxValue = values[i];
        }
    }
    return maxValue;
}

Search and Count

int linearSearch(const int values[], int size, int target)
{
    for (int i = 0; i < size; i++) {
        if (values[i] == target) {
            return i;
        }
    }
    return -1;
}

int countPasses(const int marks[], int size)
{
    int count = 0;
    for (int i = 0; i < size; i++) {
        if (marks[i] >= 50) {
            count++;
        }
    }
    return count;
}

-1 is often used to mean "not found" because it is not a valid array index.

Simple Sort Pattern

This nested-loop pattern is easy to remember for exams. It repeatedly swaps values so the smaller values move toward the front.

void sortArray(int values[], int size)
{
    for (int i = 0; i < size - 1; i++) {
        for (int j = i + 1; j < size; j++) {
            if (values[j] < values[i]) {
                int temp = values[i];
                values[i] = values[j];
                values[j] = temp;
            }
        }
    }
}

Two-Dimensional Arrays

A 2D array is useful for rows and columns, such as candidates and voting stations or students and tests.

const int ROWS = 2;
const int COLS = 3;
int votes[ROWS][COLS] = {
    {12, 8, 15},
    {9, 17, 11}
};

for (int r = 0; r < ROWS; r++) {
    for (int c = 0; c < COLS; c++) {
        cout << votes[r][c] << " ";
    }
    cout << endl;
}

Array Exam Traps

• Do not use <= size in the loop condition. Use i < size.
• Initialize totals before adding: int total = 0;.
• Initialize maximum/minimum from the first element, not from a random number.
• Pass the number of rows and columns when processing 2D arrays.
• Use nested loops for 2D arrays: outer loop for rows, inner loop for columns.

Pointer Arithmetic Walkthrough

When an array name is used in many expressions, it behaves like the address of the first element. That means marks, &marks[0], and a pointer assigned with int* p = marks; all lead to the first element.

int marks[5] = {45, 78, 66, 91, 52};
int* p;
p = marks;

for (int i = 0; i < 5; i++) {
    cout << "Address: " << (p + i);
    cout << " Value: " << *(p + i);
}

The loop does not need square brackets. The expression *(p + i) is another way to write marks[i].

Pointer Exam Reasoning

1. Write down the array values in order.
2. Place the pointer on the element it currently addresses.
3. Apply any movement such as p++, p + i, or p += 2.
4. Only read the value when you see *.

Classes and Objects

• A class groups data members and member functions into one unit.
• An object is an instance of a class.
• private members are accessible only inside the class.
• public members form the interface used by the rest of the program.
• Constructors initialize objects when they are created.

Inheritance

class Person {
protected:
    string name;
public:
    Person(string n)
    {
        name = n;
    }
};

class Student : public Person {
private:
    int studentNo;
public:
    Student(string n, int s)
        : Person(n)
    {
        studentNo = s;
    }
};

Base vs Derived Responsibilities

Constructor Order

class PartTimeStudent : public Student {
private:
    int modules;
public:
    PartTimeStudent(string n, int m)
        : Student(n)
    {
        modules = m;
    }
};

1. The base part, Student(n), is built first.
2. The derived data member, modules(m), is initialized next.
3. The constructor body runs last.

Virtual Functions

• A virtual function allows the derived class version to run through a base-class pointer or reference.
• A pure virtual function is written with = 0.
• A class with at least one pure virtual function is abstract.
• Concrete derived classes must override inherited pure virtual functions.

Overloading and Templates

• Function overloading uses one function name with different parameter lists.
• Operator overloading gives an operator a class-specific meaning.
• Templates allow a function or class pattern to work with different data types.

template <class Type>
Type larger(Type x, Type y)
{
    if (x > y) {
        return x;
    } else {
        return y;
    }
}

Overriding Checklist

• The base function must be marked virtual when runtime polymorphism is needed.
• The derived function must have the same name, return type, and parameter list.
• Use override so the compiler warns you if the signature does not match.
• A pure virtual function must be implemented before a derived class can be used to create objects.

class PartTimeStudent : public Student {
public:
    void print() const override {
        cout << "Part-time: " << name;
    }
};

Overriding vs Overloading

File I/O

• Include <fstream> for file streams.
• Use ifstream to read from files.
• Use ofstream to write to files.
• Use fstream when a file needs both input and output modes.
• Always check that the file opened successfully before processing it.

Exceptions

• An exception is an undesirable situation detected while the program runs.
• throw raises an exception.
• catch handles the exception.
• Multiple catch blocks can handle different thrown types.

Opening and Closing Files

You can open a file directly when you create the stream, or create the stream first and call open() later.

// Option 1: open immediately
ifstream inFile("marks.txt");

// Option 2: declare first, open later
ofstream outFile;
outFile.open("results.txt");

if (!outFile) {
    cout << "File could not be opened";
}

outFile.close();

File Open Modes

Writing to a File

Writing uses the insertion operator <<, just like cout.

ofstream outFile("receipt.txt");

if (!outFile) {
    cout << "Cannot create file";
} else {
    outFile << "Student: " << name << endl;
    outFile << "Fine: R" << fine << endl;
}

outFile.close();

Appending to a File

Appending is useful for logs, repeated receipts, marks added over time, or audit trails.

ofstream logFile("activity.txt", ios::app);

if (logFile) {
    logFile << "Menu option selected: ";
    logFile << choice << endl;
}

logFile.close();

Reading Values with >>

Use the extraction operator >> when the file contains simple whitespace-separated values such as marks, totals, names without spaces, or codes.

ifstream inFile("marks.txt");
int mark;
int total = 0;
int count = 0;

while (inFile >> mark) {
    total += mark;
    count++;
}

inFile.close();

Reading Whole Lines with getline

Use getline() when the file contains text that may include spaces, such as full names, addresses, or descriptions.

ifstream inFile("students.txt");
string line;

while (getline(inFile, line)) {
    cout << line << endl;
}

inFile.close();

Reading Records

A record is a group of related fields. For example, each student record might have a name, mark, and status.

// File format per line:
// name mark
// Asha 78
// Ben 62

ifstream inFile("students.txt");
string name;
int mark;

while (inFile >> name >> mark) {
    cout << name << " scored " << mark << endl;
}

inFile.close();

Processing File Data

Most exam questions ask you to read a file and calculate something: total, average, highest, count, or a filtered result.

ifstream inFile("votes.txt");
int vote;
int total = 0;
int highest = 0;

while (inFile >> vote) {
    total += vote;
    if (vote > highest) {
        highest = vote;
    }
}

cout << "Total votes: " << total << endl;
cout << "Highest: " << highest << endl;

Using fstream for Read and Write

fstream is used when the same file stream may need input and output. You specify the modes when opening.

fstream file("data.txt", ios::in | ios::out);

if (!file) {
    cout << "File error";
} else {
    string word;
    file >> word;             // read

    file.clear();             // clear stream state if needed
    file << "\\nUpdated";      // write
}

file.close();

File State Checks

Combining Files and Exceptions

You can throw an exception when a file cannot be opened, then handle the error in a catch block.

try {
    ifstream inFile("marks.txt");

    if (!inFile) {
        throw string("marks.txt could not open");
    }

    int mark;
    while (inFile >> mark) {
        cout << mark << endl;
    }
}
catch (string message) {
    cout << "File error: " << message;
}

File Handling Exam Traps

• Forgetting #include <fstream>.
• Using ifstream when you need to write.
• Using ofstream when you need to read.
• Not checking whether the file opened.
• Using while (!file.eof()) instead of checking whether the read worked.
• Forgetting that ios::out can replace existing file content.
• Using >> for full names or sentences that contain spaces.