Structured and Object Oriented: Two Ways to Organise a Program

#include <stdio.h>

/* Data is a plain bundle of fields. It knows nothing about behaviour. */
struct Account {
    char owner[32];
    long balance;
};

/* Behaviour lives outside, as functions that receive the data they need. */
void deposit(struct Account *a, long amount)
{
    a->balance += amount;
}

int withdraw(struct Account *a, long amount)
{
    if (amount > a->balance) {
        return 0;
    }
    a->balance -= amount;
    return 1;
}

void print_account(struct Account a)
{
    printf("%s has %ld\n", a.owner, a.balance);
}

int main(void)
{
    struct Account amara = {"Amara", 500};

    deposit(&amara, 300);
    print_account(amara);

    if (withdraw(&amara, 1000) == 0) {
        printf("not enough money\n");
    }
    print_account(amara);

    return 0;
}

Amara has 800
not enough money
Amara has 800

Notice the separation. struct Account holds data and knows nothing about printing. print_account holds behaviour and is handed the data. Nothing in this program is hidden from anything else.

You are not learning C++ today. Read this for its shape, and compare the output.

#include <iostream>
#include <string>

// Data and behaviour live inside one capsule, and the data is hidden.
class Account {
private:
    std::string owner;
    long balance;

public:
    Account(std::string name, long start) : owner(name), balance(start) {}

    void deposit(long amount)
    {
        balance += amount;
    }

    bool withdraw(long amount)
    {
        if (amount > balance) {
            return false;
        }
        balance -= amount;
        return true;
    }

    void print() const
    {
        std::cout << owner << " has " << balance << "\n";
    }
};

int main()
{
    Account amara("Amara", 500);

    amara.deposit(300);
    amara.print();

    if (!amara.withdraw(1000)) {
        std::cout << "not enough money\n";
    }
    amara.print();

    return 0;
}

Amara has 800
not enough money
Amara has 800

Same three lines out. Two real differences went in. The functions now live inside the class, so you write amara.deposit(300) instead of deposit(&amara, 300). And balance is private, so no code outside the class can change it by hand.

Now look at Kenji's discovery. Inside withdraw, the body is a selection followed by two steps in sequence. The three moves did not go anywhere.

The university now needs teachers as well as students. A teacher has a name and a salary, and no marks. In the structured shape you add a second bundle and a second function.

#include <stdio.h>

/* Two kinds of thing. Each gets its own bundle and its own function. */
struct Student {
    char name[32];
    int marks;
};

struct Teacher {
    char name[32];
    long salary;
};

void print_student(struct Student s)
{
    printf("student %s scored %d\n", s.name, s.marks);
}

void print_teacher(struct Teacher t)
{
    printf("teacher %s earns %ld\n", t.name, t.salary);
}

/* The three moves, inside one ordinary function. */
int count_passing(struct Student list[], int n, int pass_mark)
{
    int passed = 0;                       /* sequence */

    for (int i = 0; i < n; i++) {         /* repetition */
        if (list[i].marks >= pass_mark) { /* selection */
            passed++;
        }
    }

    return passed;                        /* sequence */
}

int main(void)
{
    struct Student class_list[3] = {
        {"Kenji", 91},
        {"Bob", 38},
        {"Zara", 77}
    };
    struct Teacher maria = {"Maria", 48000};

    for (int i = 0; i < 3; i++) {
        print_student(class_list[i]);
    }
    print_teacher(maria);

    printf("%d of 3 passed\n", count_passing(class_list, 3, 40));
    return 0;
}

student Kenji scored 91
student Bob scored 38
student Zara scored 77
teacher Maria earns 48000
2 of 3 passed

Two functions with almost the same name, and the caller has to pick the right one. With two kinds of thing this is fine. With twenty kinds, object oriented programming starts to earn its cost. An object can simply be asked to print itself.

Look at count_passing too. It is labelled with the three moves. It is also the exact shape of every loop you will write from Module 6 onward.