Hunter Liu's Website

14. Week 8 Tuesday: Object-Oriented Programming and Structs

When we talked about functions, we described how certain natural formulations of pseudocode were difficult to translate into code directly. Namely, this occurred when we wanted to describe high-level actions and processes whose details didn’t “fit” concisely into our pseudocode. For instance, it’s sometimes natural to write if n is prime... in pseudocode. Rather than describing the entire process of determining whether or not a number is prime, we decided to keep it inside a function instead. This produces a more natural structure for our program, as it more closely follows the pseudocode one may produce.

However, there’s another type of difficulty that arises in writing pseudocode, and it’s related to how we organise variables throughout our program. Consider the following scenario:

One fortunate thing about this problem is that it’s already in pseudocode, more or less. It’s lacking some specificity, though, and one particular point that it’s missing is how we should be keeping track of all the menu items the user has entered.

An idea is to keep three separate vectors: one for the names, one for the sections, and one for the prices. However, this is kind of unnatural. The pseudocode groups the user’s data by menu item: each name, section, and price, is, in a sense, a single “unit” of data. Step four in particular suggests that we iterate over the menu items, and this is made rather difficult if the names, sections, and prices are in separate vectors.

Moreover, this has a maintainability issue: making adjustments to a program like this is difficult and prone to error. Suppose you needed to indicate which menu items were gluten-free; one would need to produce a fourth vector of booleans and make major adjustments to step 4, even though this won’t impact how the discounts are calculated!

Similar to ho we taught C++ how to check if a number was prime or not, we should be teaching C++ what a “menu item” is, how to print it, and how to take discounts of a menu item. This will lead to a much more natural organisation of code, and it will be one that lines up much more closely to our “pseudocode” above.

A “menu item” is what we call an “object” — it’s a collection of data that has some additional functionality. Strings and vectors are objects we’ve been handling already! This idea is central to a design paradigm caled Object-Oriented Programming (which we won’t go into farther detail about here).

Basic Syntax of Structs: Member Variables

To define a new struct, we must tell C++ what kinds of data it contains as well as the types of actions it can perform. This boils down to giving the struct some variables and some functions.

Let’s start by giving our struct some variables, which are called member variables. In our case, each menu item has a name, a type, and a price.

1struct menu_item {
2    string name;    // what the menu item is called
3    string type;    // appetiser, entree, etc. 
4    double price;   // self explanatory...
5};

Notice the semicolon at the end of the struct! This defines a new variable type for C++ — it’s a menu item, which holds two strings (a name and a type) together with a double (its price).

To declare a new variable of this type, we declare it just like any other variable: menu_item entree;. However, this has a problem: its name, type, and price are still uninitialised! We haven’t told this entree what it’s called, what its type is, and how much it costs. To do so, we list the values of its constituent variables in the order that they appear as follows:

1menu_item entree = {"Wild Mushroom Risotto", "Entree", 47.99}; 

This creates a menu item called “Wild Mushroom Risotto”, which is an “Entree” that costs an egregious $47.99.

We can access the name, type, and price of our entree and print something out as follows:

1cout << entree.name 
2     << " (" << entree.type << ") " 
3     << "$" << entree.price << endl;

This would produce the output Wild Mushroom Risotto (Entree) $47.99. In general, the syntax for accessing a member variable is [object name].[member variable].

Basic Syntax of Structs: Constructors

The above method of initialising structs is not best practise, and for a variety of reasons. First, it depends on the order in which the member variables of our struct was declared, and moreover, we would need to know all of the member variables in order to do this! For things like strings and vectors, this is completely opaque to us, and this method of initialisation is completely inaccessible.

Second, and more importantly, we often times don’t need to initialise every single member variable explicitly. For instance, if we had additional fields for profits and tax, these could be computed directly from the price variable rather than provided explicitly.

The workaround is a special function called a constructor, which takes in only the necessary information for a struct and fills out all of the member variables itself. The constructor has no return type, not even a void type, and its name must be the same as the struct’s name. We can write a constructor for our menu_item struct as follows:

 1struct menu_item {
 2    string name; 
 3    string type; 
 4    double price; 
 5
 6    // hypothetical "tax" field 
 7    double tax; 
 8
 9    // constructor! 
10    menu_item(string new_name, string new_type, double new_price) {
11        name = new_name; 
12        type = new_type; 
13        price = new_price; 
14        tax = 0.0875 * price;   // automatically compute the tax! 
15    }
16}; 

Lines 7 and 14 demonstrate how one can use a constructor to fill in parts of our struct without needing to provide a value for each member variable.

A word of caution: it is tempting to write menu_item(string name, string type, double price), but this causes a critical issue. In the body of the constructor, C++ would have a hard time distinguishing between the member variable name and the constructor’s parameter name.

We can use a constructor as follows:

1menu_item entree("Wild Mushroom Risotto", "Entree", 47.99); 

Note that this uses parentheses rather than curly braces. We’ll discuss another important facet of why constructors are important later, when we talk about private vs. public member variables and functions.

Basic Syntax of Structs: Member Functions

In the first section, we gave some code for printing out a menu item with a nice format. However, it’s rather painful to repeat this every time we need to print out a menu item. Moreover, suppose we decide somewhere along the way to change how we’re formatting this output — we would have to comb through our code and make changes at many different points to enact this change.

In addition, some feasible pseudocode would likely read, print out a menu item, and our code should reflect this level of simplicity.

The way around this is to write a function! A tempting first guess is

1void print_menu_item(menu_item m) {
2    // ...
3}

This is an alright approach, but we’ll identify some shortcomings of this when we talk about privacy and publicity of member variables. Instead, the object-oriented approach is to give menu_item’s the ability to print themselves out. What I mean is:

 1struct menu_item {
 2    string name; 
 3    string type; 
 4    double price; 
 5
 6    menu_item(string new_name, string new_type, double new_price) {
 7        name = new_name; 
 8        type = new_type; 
 9        price = new_price; 
10    }
11
12    void print() {
13        cout << name << " (" << type << ") $" << price << endl; 
14    }
15}; 

Here’s an example of how we could use this print function:

1menu_item risotto("Wild Mushroom Risotto", "Entree", 47.99);
2menu_item sorbet("Pineapple Sorbet", "Dessert", 9.99); 
3
4risotto.print(); 
5sorbet.print(); 

This would produce the following output:

Wild Mushroom Risotto (Entree) $47.99
Pineapple Sorbet (Dessert) $9.99

Again, the idea is that we’re teaching C++ about the different “actions” one can perform with a menu_item, and so far, we’ve described how to construct one and how to print one out.

Something to be aware of is that although we’ve called the “same” print() function twice, we got two distinct outputs. That’s because we first told risotto to print itself out, and its print function has access to risotto’s member variables. Then, we told sorbet to print itself out, which has access to a different set of member variables. The two functions do the same thing and have the same code, but they use and access different sets of member variables.

The last thing we’re missing is a discount function. Try to fill that out yourself before looking at the following code:

 1struct menu_item {
 2    string name; 
 3    string type; 
 4    double price; 
 5
 6    menu_item(string new_name, string new_type, double new_price) {
 7        name = new_name; 
 8        type = new_type; 
 9        price = new_price; 
10    }
11
12    void print() {
13        cout << name << " (" << type << ") $" << price << endl; 
14    }
15
16    void discount(double rate) {
17        price *= (100.0 - rate) / 100.0; 
18    } 
19}; 

This discount function will modify the price of its menu item based on how much we’re discounting it by. For instance,

1menu_item risotto("Wild Mushroom Risotto", "Entree", 47.99); 
2risotto.discount(10); // takes 10% off 
3risotto.print(); 

will produce the output Wild Mushroom Risotto (Entree) $43.191. Perhaps we should modify the print function to round the price to the nearest hundredth…try to do that yourself!

The Public and Private Keywords

Something we should consider is that the price should never ever be negative. Perhaps something we could do is modify the constructor slightly to account for negative prices; if it encounters one, it can instead set the price to zero.

 1struct menu_item {
 2    string name; 
 3    string type; 
 4    double price; 
 5
 6    menu_item(string new_name, string new_type, double new_price) {
 7        name = new_name; 
 8        type = new_type; 
 9        price = new_price; 
10
11        // no negative prices! 
12        if(price < 0) {
13            price = 0; 
14        }
15    }
16
17    void print() {
18        cout << name << " (" << type << ") $" << price << endl; 
19    }
20
21    void discount(double rate) {
22        price *= (100.0 - rate) / 100.0; 
23    } 
24}; 

However, what’s stopping someone from doing the following?

1menu_item breath_mint("Breath Mint", "Dessert", -0.50); 
2breath_mint.price = -0.50; 

Absolutely nothing!

In OOP, a core design paradigm is that none of the member variables should even be directly accessible to the main program; they should only be directly modifiable by member functions. This is so that things like the above don’t happen.

In general, when we define a new struct, it shouldn’t matter what kinds of variables are on the inside. When we interact with structs in pseudocode, we’re always performing some sort of action with them, such as

• obtaining a specific property or description,
• formatting some output related to the object,
• modifying some properties of the object, etc. These can all be framed as “actions” that can be performed by or on the object, and thus we should encapsulate these in member functions. We should never be able to directly change the underlying member variables of our structs.

To separate these, we use the public and private keywords as follows:

 1struct menu_item {
 2private: 
 3    string name; 
 4    string type; 
 5    double price; 
 6
 7public: 
 8    menu_item(string new_name, string new_type, double new_price) {
 9        name = new_name; 
10        type = new_type; 
11        price = new_price; 
12
13        // no negative prices! 
14        if(price < 0) {
15            price = 0; 
16        }
17    }
18
19    void print() {
20        cout << name << " (" << type << ") $" << price << endl; 
21    }
22
23    void discount(double rate) {
24        price *= (100.0 - rate) / 100.0; 
25    } 
26}; 

Anything under private can only be referenced by the struct’s own functions, and they are “invisible” to the rest of the program. Anything in public is fully exposed to the rest of the program. Generally, all of the member variables should be under private while all of the member functions should be under public.

 1struct menu_item {
 2private: 
 3    double price;
 4    // ...
 5
 6public: 
 7    double get_price() {
 8        return price; 
 9    }
10
11    void set_price(double new_price) {
12        if(new_price < 0) {
13            price = 0; 
14        } else {
15            price = new_price; 
16        }
17    }
18
19    // ...
20}; 

By default, everything in a struct is public unless we specify otherwise.

Going back to our remark earlier about the print_menu_item function we proposed, this would not work anymore because it won’t have access to the private member variables of the menu_item struct! Keeping them private forces us to think about objects in terms of the actions they can take, and this principle is called encapsulation.

As they say, if it walks like a duck and sounds like a duck, it’s a duck.

Putting It All Together

We are now ready to build a program to answer the example problem posed at the beginning. Let’s provide some more detailed pseudocode:

1. Create an empty list of menu items called menu.
2. Ask the user for a name (string), a type (string), and a price (double). Create a new menu item with this data and append it to the menu.
3. Ask the user if they want to enter another menu item.
   • If yes, go back to step 2.
   • If no, keep going to the next step.
4. Ask the user for 3 discount rates: one for appetisers, one for entrees, and one for desserts.
5. For each menu item in menu, perform the following:
   • If the item’s type is Appetiser, apply the appetiser discount rate.
   • Otherwise, don’t do anything.
6. Print out each item in menu, one at a time. From this, we see that we do need to be able to check a menu_item’s type, and so we should provide a member function to retrieve this property. This is what our final code should look like:

 1#include <iostream>
 2#include <string> 
 3#include <vector> 
 4
 5using namespace std; 
 6
 7struct menu_item {
 8private: 
 9    string name; 
10    string type; 
11    double price; 
12
13public: 
14    // creates a new menu item with the given name, type, and price
15    menu_item(string new_name, string new_type, double new_price) {
16        name = new_name; 
17        type = new_type; 
18        price = new_price;
19
20        if(price < 0) {
21            price = 0; 
22        }
23    }
24
25    // prints out a menu item in the format 
26    // NAME (TYPE) $PRICE 
27    void print() {
28        cout << name << " (" << type << ") $" << price << endl; 
29    }
30
31    // applies the given discount rate to the menu item.
32    void discount(double rate) {
33        price *= (100.0 - rate) / 100.0; 
34    }
35
36    // retrieves the type of the menu item 
37    string get_type() {
38        return type; 
39    }
40}; 
41
42int main() {
43    // 1. create a vector of menu_items to represent the menu
44    vector<string> menu; 
45
46    // 2 and 3. repeatedly ask the user for new menu items. 
47    string more_items = "Y"; 
48    while(more_items == "Y") {
49        string name, type;
50        double price; 
51
52        cout << "Enter the menu item's name:  "; 
53        getline(cin, name); 
54        cout << "Enter the menu item's type:  "; 
55        getline(cin, type); 
56        cout << "Enter the menu item's price: "; 
57        cin >> price; 
58
59        // create a new menu_item, then push it onto the menu.
60        menu_item new_item(name, type, price); 
61        menu.push_back(new_item); 
62
63        // ask them if they want to keep going 
64        cout << "Would you like to enter more? (Y/N) "; 
65        cin >> more_items; 
66    }
67
68    // 4. ask for a discount rate for appetisers, entrees, 
69    // and desserts
70    double appetiser_rate; 
71    cout << "Enter the appetiser discount rate: "; 
72    cin >> appetiser_rate; 
73
74    // 5. scan through the menu, applying the appropriate discount
75    // rate as we go. 
76    for(int i = 0; i < menu.size(); i++) {
77        if(menu.at(i).get_type() == "Appetiser") {
78            menu.at(i).discount(appetiser_rate);
79        }
80    }
81
82    // 6. scan through the menu and print things out one by one 
83    for(int i = 0; i < menu.size(); i++) {
84        menu.at(i).print(); 
85    }
86
87    return 0; 
88}

To wrap things up, the main takeaway for the object-oriented paradigm is that the structure of our code is centred around struct and objects. The bulk of our work is setting up these objects — teaching C++ what each object is made of and what they can do. This allows us to write pretty natural code that reflects how we think about many processes as humans!

There is much more you can do with structs (and classes), many of which give us ways to extend some level of human intuition into code. We’ll see these in the coming weeks!