Topics to Cover

• How do you create a pointer variable?
• What is the deference operation?
• Can you draw pictorial diagrams for expressions containing pointers?
• Can you identify the type of expressions containing pointers?
• How are address-of and dereference operators different?

What is a pointer?

We already discussed some of these topics, but pointers are very important, so we want to make sure everyone is comfortable with them.

We have stressed so far that every expression has a type and a value.

Pointer type

int n = 3;
cout << &n << endl; // what is the type of &n?

double x = 1.0;
char c = 'a';
string s = "hello";
bool b = false;

cout << &x << endl; // &x is of type double*
cout << &c << endl; // &c is of type char*
cout << &s << endl; // &s is of type string*
cout << &b << endl; // &b is of type bool*

In general:

Declaring a pointer variable

int* p;

Value of a pointer variable: address

int n = 1;
int* p;
p = &n;  // This assignment makes sense: typeof(p) = int* = typeof(&n)

Dereference: accessing an object given an address

Indeed, if you have an address, you can access an object at that address in memory. We call this operation is "dereference". The deference operator is *.

In a sense, we have two operators having the opposite direction from each other. In particular:

int n = 10;
int* p;
p = &n; 
cout << *p << endl;

Check your understanding

int a = 10, b = 7;
int* p = &b; 
*p = 5;
cout << a << " " 
     << b << endl;

10 5

The picture shows that there are two ways to access an object: by using the name of a variable (i.e., using expression b). by using the address of a variable (i.e., using expression *p). Using this diagram, you can remember the deference operation *p as follows: Follow the arrow! Note that *p works exactly the same as p[0]. When a pointer points to a single object rather than an array, *p gives better readibility of your code.

Dereference (i.e., *) and indexing (i.e., [])

Since p points to the first element of the array, *p is actually the same as p[0]. Applying the same logic, it also holds that p[i] is the same as *(p+i).

p[i] is equivalent to *(p+i)

Other Questions

// mem.cpp
 1 #include <iostream>
 2 #include <string>
 3 using namespace std;
 4
 5 int main()
 6 {
 7   int a = 10, b = 7;
 8   int* p;
 9
10   cout << "&a=" << &a << ", &b=" << &b << ", &p=" << &p << endl;
11   cout << "a=" << a << ", b=" << b << endl;
12
13   uint64_t addr;          // uint64_t: 64-bit unsigned integer 
14   cin >> hex >> addr;     // hex: read in the hexadecimal format
15   p = (int*) addr;        // now p contains the address from the terminal
16 
17   cout << "*p=" << *p << endl;
18   return 0;
19 }

&a=0x7ffff83497e0, &b=0x7ffff83497e4, &p=0x7ffff83497e8
a=10, b=7

Question 1

1. Give a memory diagram, when the user input from the terminal at line 14 is 0x7ffff83497e0.

   Answer: (Make sure you can draw the following diagram by youself).

    address                value                    (variables)
   ...
   0x7ffff83497e0            10              a
   0x7ffff83497e4            7               b
   0x7ffff83497e8       0x7ffff83497e0       p
   ...
   

2. What will be the output from line 17? Answer:

   10

   Note: In this case, *p corresponds to an int object at address 0x7ffff83497e0. Well, the int object at address 0x7ffff83497e0 is actually the variable a.

Question 2

Heads up! Different meanings for the same symbols

Usage of operator*

int* p;            // this is a declaration
                   // * means pointer declaration

*p = 7;            // *p is an expression;  the*  is used as a unary rather than binary operator
                   // * means dereference

cout << 3*7;       // 3*7 is an expression, and the*  is used as a binary operator
                   // *  means multiplication

Rule of thumb

Questions

char* S;
double** A;
int n;