Hunter Liu's Website

18. Week 10 Thursday: Pointers

Welcome to the last class of the quarter! Congratulations on making it this far.

Our last topic is pointers, which are actually related to (C-style) arrays. Our closest brush with memory management was when we talked about passing parameters by reference, so keep those concepts in mind for today’s discussion!

A Motivating Example

Suppose you’re the manager at a restaurant, and you guys sell seafood at a variable market price. It’s a large restaurant, and your waitstaff has dozens and dozens of waiters and waitresses. The issue, of course, is keeping all of these waitstaff up-to-date on the menu’s prices every day.

On one hand, you could just tell every single employee what the market prices are when they clock in every day. However, this is tedious and prone to both error and extenuating circumstance. What if you misremember the price of lobster ravioli? What if someone comes in half an hour late and you have to stop what you’re doing to get them caught up?

You, being a certified genius of restaurant management, decide there’s a better solution: rather than just telling your staff what all the prices are individually, you buy a whiteboard and tell your waitstaff to refer to the whiteboard for the market prices. This keeps everybody consistent, and whenever the market prices change from day to day, you no longer have to check in with your dozens and dozens of waitstaff and update them.

This is perhaps not the most precise example, but the point is that there’s a single copy of data — the variable prices on your menu — that the waiters and waitresses are expected to know. Rather than telling them what the data is, you’ve told them where to find it.

Similar scenarios arise in code quite frequently: you have a bunch of objects that need to hold a synchronised piece of data. Rather than keeping a copy of this data in each object, then manually keeping them in sync, we can have a single copy of data somewhere in memory, then tell all of the objects where to find it.

Memory Addresses and Pointers

Consider the following code:

1int a = 15; 
2cout << a << endl; 

This declares an integer called a and sets its value to 15. When we humans read this code, we interpret a as just the value as 15 — nothing more, nothing less.

However, a is more than the number 15 to the computer. Since your computer needs a way to “remember” the number 15, it sections off a little bit of physical memory and puts the number 15 there. To the computer, the variable a doesn’t represent the number 15 — it represents the location or memory address where 15 was stored.

This memory address is usually hidden from us, as we would usually rather work with the number 15 rather than the memory address 0x7fff0e28eab4. Thus, C++ understands that when we say cout << a << endl;, it’s supposed to go to the memory address that a stores and print out the data that it put there, not the memory address!

There are times, however, when would like to use the memory address itself. Think about the waitress example, where we told our employees where a piece of data was. We should be able to do something similar in code: remember where a specific variable is, then reference it from different parts of a program.

 1void foo(int &a) {
 2    a += 1; 
 3}
 4
 5int main() {
 6    int x = 15; 
 7    foo(x); 
 8    cout << x << endl; 
 9    return 0; 
10}

A pointer is a variable whose value is a memory address, typically another variable’s memory address! In a sense, a pointer variable stores where another variable is located. For instance,

1int a = 15; 
2int* p = &a; 

This code first declares a variable a of type int and stores the value 15 in it. The second line is somewhat tricky, and there’s two parts:

• int* p declares a variable called p, and it’s type is int*. The * indicates that it’s a pointer — it holds a memory address — and the int indicates that data located at that memory address should be an integer.
• On the right side, &a means the “address of a” (the & is called an address operator). Thus, p contains the location in memory where the integer a is stored.

There’s an additional operator called the “dereferencing operator”. Consider the following code:

1int a = 15; 
2int* p = &a; 
3
4*p = 17; 
5cout << a << endl; 

The output is 17! The the magic happens on line 4 — the * in front of p is the dereferencing operator, and it tells C++ to “go to the memory address p, then put the value 17 there”. The memory address of p is the same as the location where a is stored! Thus, when C++ tries to figure out what a is, it sees the 17 we put in its memory address.

Pointers to Objects

Consider the following two classes:

 1class child {
 2private: 
 3    string name; 
 4
 5public: 
 6    // creates a new child with the given name. 
 7    child(string new_name) {
 8        name = new_name; 
 9    }
10
11    // gets the name of this child. 
12    string get_name() {
13        return name; 
14    }
15
16    // renames this child. 
17    void rename(string new_name) {
18        name = new_name; 
19    }
20}; 

This first class is a simplistic model of a child. It is nothing more than a string (their name). The constructor takes the new child’s name as an argument, and there are public functions that allow the program to get the name and rename it.

 1class parent {
 2private: 
 3    string name; 
 4    child offspring; 
 5
 6public: 
 7    // creates a new parent with the given name and offspring. 
 8    parent(string new_name, child new_offspring) {
 9        name = new_name; 
10        offspring = new_offspring; 
11    }
12
13    // gets the parent's name 
14    string get_name() {
15        return name; 
16    }
17
18    // gets the offspring's name 
19    string get_offspring_name() {
20        return offspring.get_name(); 
21    }
22
23    // renames the offspring 
24    void rename_offspring(string new_name) {
25        offspring.rename(new_name); 
26    }
27}; 

This is another simplistic class that models a parent, who is nothing more than a name and a single child. The parent can produce their name or their offspring’s name, and they can also rename their child.

Now consider the following code:

1int main() {
2    child son("Billy"); 
3    parent father("Billiam", billy); 
4
5    father.rename_offspring("Bilbo"); 
6    cout << son.get_name() << endl; 
7    cout << father.get_offspring_name() << endl; 
8    return 0; 
9}

Lines 2 and 3 declare a child named Billy and a father named Billiam. Line 5 asks Billiam to rename his kid to Bilbo. However, the output is Billy followed by Bilbo — somehowe, the son variable is not the father variable’s offspring!

The issue is that the variable son in main and the private variable offspring belonging to father are two completely separate variables. The rename_offspring function only changes the latter; son remains unchanged after line 5. This is strange behaviour! We only ever declared one child variable, yet suddenly they’re multiplying. We have more children than we asked for.

The fix here is to use a pointer to a child in the parent class instead. This is similar to passing by reference in that this will grant the parent class direct access to whatever child variable is given to them in the constructor. This is the new parent class:

 1class parent {
 2private: 
 3    string name; 
 4    child* offspring; 
 5
 6public: 
 7    // creates a new parent with the given name and offspring. 
 8    parent(string new_name, child* new_offspring) {
 9        name = new_name; 
10        offspring = new_offspring; 
11    }
12
13    // gets the parent's name 
14    string get_name() {
15        return name; 
16    }
17
18    // gets the offspring's name 
19    string get_offspring_name() {
20        return (*offspring).get_name(); 
21    }
22
23    // renames the offspring 
24    void rename_offspring(string new_name) {
25        offspring->rename(new_name); 
26    }
27}; 

Several things to note:

• Line 4 was changed so that each parent no longer has a child variable, but rather a pointer to a child variable.
• Line 8 was changed so that the parent’s constructor accepts a pointer to a child rather than just a child. Note that line 10 stays the same.
• Line 20 was changed — it’s no longer correct to say offspring.get_name(), as you can’t get a memory address’ name. Instead, (*offspring) tells C++ to go to the memory address stored by offspring, which is a child object, then ask for its name.
• Line 25 illustrates a different way of doing this: the -> operator represents accessing a member variable or function from a pointer to an object. Both options are valid for this class, and they are essentially the same thing!

Now let’s quickly rewrite the main function!

1int main() {
2    child son("Billy"); 
3    parent father("Billiam", &son); 
4
5    father.rename_offspring("Bilbo"); 
6    cout << son.get_name() << endl; 
7    cout << father.get_offspring_name() << endl; 
8    return 0; 
9}

This time, we get Bilbo on both lines! Success!

Practise Problems

Here are two short and sweet practise problems involving predicting the output of code that uses pointers. I may add more practise problems later, but as you are all aware, finals are approaching…we’ll see if I have the time.

 1#include <iostream> 
 2#include <string> 
 3
 4using namespace std; 
 5
 6void foo(int n, string* p) {
 7    for(int i = 0; i < n; i++) {
 8        (*p).push_back('*'); 
 9    }
10}
11
12int main() {
13    string s = "abcdef"; 
14    foo(3, &s);
15    cout << s << endl; 
16
17    return 0; 
18} 

 1#include <iostream> 
 2#include <string> 
 3
 4using namespace std; 
 5
 6int main() {
 7    string s1 = "abcd"; 
 8    string s2 = "efgh"; 
 9
10    string* p1 = &s1; 
11    string* p2 = &s2; 
12    string* p3 = p1; 
13
14    for(int i = 0; i < s2.size(); i++) {
15        if(p1->at(i) == 'c') {
16            p2->push_back('d'); 
17            p1->push_back('a'); 
18        } 
19
20        p3->push_back('c'); 
21    }
22
23    cout << s1 << endl; 
24    cout << s2 << endl; 
25
26    return 0; 
27}