Pointers & References in C++

Pointers & References
Ilio Catallo - info@iliocatallo.it

Outline
• The swap func*on
• Memory & addresses
• Pointers
• References
• Bibliography

Swapping integers
Assume that we are wri-ng a program in which we o3en need to
swap two integers
┌──────────────────┐
│ │
│ ▼
┌───┐ ┌───┐
a:│ 2 │int b:│ 5 │int
└───┘ └───┘
▲ │
│ │
└──────────────────┘

Idea: wri%ng a swap_int func%on

Invoking swap_int
int main() {
int a = 2;
int b = 5;
// expected result: a = 5, b = 2
swap_int(a, b);
}

How to write the swap_int func.on?

First a(empt
void swap_int(int x, int y) {
int temp = x;
x = y;
y = temp;
}

First a(empt
At swap_int invoca*on:
• The values in a and b get copied into the local variables x and y
• The values in x and y get swapped, but...
• The values in a and b remain untouched

First a(empt
void swap_int(int x, int y) {
...
}
int main() {
int a = 2, b = 5;
swap_int(a, b); // x and y are copies of a and b
// hence, a and b remain unchanged
}

The swap problem
We conclude that it is not possible to write the swap_int
func1on if we pass parameters by value

Memory
During the execu-on of a program, data are stored in memory

Memory model
In C++, memory is modeled as a sequence of memory cells, where
each cell is of size 1 byte
┌──────┬──────┬──────┬──────┐
... │ │ │ │ │ ...
└──────┴──────┴──────┴──────┘
◀─────▶
1 byte

Memory model
Each memory cell is associated with a unique memory address
┌──────┬──────┬──────┬──────┐
... │ │ │ │ │ ...
└──────┴──────┴──────┴──────┘
0x7345

Memory model
Memory addresses are nothing more than numbers1
┌──────┬──────┬──────┬──────┐
... │ │ │ │ │ ...
└──────┴──────┴──────┴──────┘
0x7345
1
The 0x preﬁx is to say that the numbers are given in hexadecimal nota6on

Memory model
Given a cell, its address is obtained as the address of the previous
one plus one
┌──────┬──────┬──────┬──────┐
... │ │ │ │ │ ...
└──────┴──────┴──────┴──────┘
0x7345 0x7346 0x7347

Memory model
This assures that:
• Every memory cell has its own unique address
• Given a cell, it is possible to compute the address of its
neighborhood

Variable iden+ﬁers
We usually do not care about where values are stored
int a
◀───────────▶
┌──────┬──────┬──────┬──────┐
... │//////│//////│ │ │ ...
└──────┴──────┴──────┴──────┘
0x7345 0x7346 0x7347

Variable iden+fiers
We simply manipulate values by referring to the iden%fier of the
corresponding variable
int a = 3;
a = a + 7; // we do not know where à` is stored in memory

Addresses
However, there might be situa2ons in which we would like to refer
to the in-memory loca-on of a value, rather than to the value itself

The ampersand
In order to manipulate the address of a variable, we preﬁx the
variable iden8ﬁer with the ampersand symbol &

The ampersand
int a = 5;
std::cout << "value of a: " << a
<< std::endl;
std::cout << "address of a: " << &a
<< std::endl;

The address-of operator
When the ampersand symbol & precedes an expression2
, it plays
the role of a unary operator (the address-of operator)
int a = 7;
std::cout << &a; // conceptually: address_of(a);
2
Note that there exist expressions on which it is not possible to apply the address-of operator

The address-of operator
Note that if a value occupies more than one memory cell, the
address-of operator returns the address of the ﬁrst memory cell
int a
◀───────────▶
┌──────┬──────┬──────┬──────┐
... │//////│//////│ │ │ ...
└──────┴──────┴──────┴──────┘
0x7345 0x7346 0x7347
▲
│
│
&a

A formal deﬁni.on of copy
A copy is a something that is equal to the original but not iden)cal
to it
int a = 7;
int b = a;
a == b; // b is equal to a (they both contain 7)
&a != &b; // b is not a (they live in different memory locations)

Storing addresses
Assume that we now want to store the address of a value. We need
a variable where to keep such an address

Storing addresses
int a = 7;
??? address_of_a = &a

What is the type of address_of_a?

Pointer to int
The data type of a variable storing the address of an int is int*.
Such a data type is called pointer to int
int* address_of_a = &a

Pointers
Variables that store addresses are called pointers
It is possible to create pointers to any data type3
, for built-in and
user-deﬁned types alike
3
As long as the data type is at least of size 1 byte

For any data type T, T* is the data type pointer to T

Examples
int* a; // pointer to int
char* b; // pointer to char
float* c; // pointer to float
int** d; // pointer to pointer to int

Pointers as type constructors
The * symbol plays the role of a type constructor
A type constructor is a func0on that takes as input some type T
and returns some other type T'

Example
Construc)ng the type "pointer to int"
• Input type: int
• Type constructor: *
• Output type: int*

vector as type constructor
No#ce that also std::vector is a type constructor

vector as type constructor
Indeed, no value can have a type of just std::vector, because
that is not a type per se

Example
Construc)ng the type "vector of double's"
• Input type: double
• Type constructor: std::vector
• Output type: std::vector<double>

Type constructors: a metaphor
Type constructors are like ♭ and ♯ in music

You cannot play ♭ or ♯ alone

You rather apply ♭ or ♯ to a note to obtain a new one

Construc)ng the note A♭
• Input note: A
• Note constructor: ♭
• Output note: A♭

Using pointers
Assume we are storing the address of an integer variable in a
pointer
int* ptr = ... // somehow initialized

What opera*ons can I do on pointers?

Dereferencing
The dereference operator * makes possible to access the content
pointed to by a pointer4
int* ptr = ...
std::cout << "the value pointed to is: " << *ptr;
4
The dereference operator is also called the indirec'on operator

Dereferencing
The expression *ptr reads "the value pointed to by ptr"
int* ptr = ...
std::cout << "the value pointed to is: " << *ptr;

Dereferencing
The dereference operator allows both reading and modifying the
pointed value
int* ptr = ...
*ptr = 7;
int b = 5 + *ptr; // b contains 12

Dereferencing
In other words, the expression *ptr may also appear on the le4-
hand side of the assignment operator
int* ptr = ...
*ptr = 7;
int b = 5 + *ptr; // b contains 12

Same symbol, two meanings
// * is a type constructor
int* ptr_a = &a;
// * is an operator
std::cout << "pointed value: " << *ptr_a;

Trivia 1: What's the output?
int a = 7;
int* ptr = &a;
*ptr = 12;
std::cout << *ptr << std::endl;
std::cout << a << std::endl;

int a = 7;
int* ptr = &a;
std::cout << &ptr << std::endl;
std::cout << &a << std::endl;

int a = 7;
int* ptr1 = &a;
int* ptr2 = &a;
std::cout << (ptr1 == ptr2) << std::endl;
std::cout << (&ptr1 == &ptr2) << std::endl;

The "box" metaphor
Just as a vector is a container of many elements, we can say that a
pointer is a container of one element5
5
More formally, the similarity holds because both of them are functors

The "box" metaphor
// we put some values in the container
std::vector<int> v = {1, 2, 3, 4, 5};
// accessing the 3rd element
// in the container
std::cout << v[2];

The "box" metaphor
// we "put" a value in the container
int* p = &a;
// accessing the only element
// in the container
std::cout << *p;

The strange case of null pointers

Unini$alized pointers
As with any local variable, it is not possible to foresee the value of
unini6alized pointers
int* ptr; // uninitialized pointer

The pointer may hold any value. Such a value will be erroneously
intended as the address of a pointed value

There does not exist any way to understand whether a pointer is in
fact poin4ng to a valid value

Null pointers
We would like to ini#alize pointers even in the absence of a
sensible value
int* ptr = ???;

Null pointers
Pointers can be ini-alized to null in order to indicate that the
pointer is currently not poin-ng to any valid value6
int* ptr = nullptr; // since C++11
int* ptr = NULL; // C++03
6
In terms of the box metaphor, this amounts to no4fying that the container is empty

Solving the swap problem
Can we use pointers to write a working version of the swap_int
func4on?

Idea: passing to swap_int the variable addresses (as
opposed to their values)

swap_int with pointers
void swap_int(??? x, ??? y) {
...
}

void swap_int(int* x, int* y) {
...
}

void swap_int(int* x, int* y) {
int temp = *x;
*x = *y;
*y = temp;
}

At swap_int invoca*on:
• The addresses of a and b get copied into the pointers x and y
(which are local to swap_int)
• The values pointed to by x and y (i.e., a and b) get swapped
• At the end of swap_int, x and y get destroyed

How to invoke swap_int?
int main() {
int a = 2;
int b = 5;
swap_int(???, ???);
}

int main() {
int a = 2;
int b = 5;
swap_int(&a, &b);
}

Passing by address
If a func(on receives addresses in place of values, we say that
parameter are passed by address
void swap_int(int* x, int* y);

Passing by address
However, since we pass address copies, passing by address is just a
par6cular case of passing by value
void swap_int(int* x, int* y);

Passing by address
Passing by address allows...
• propaga'ng altera'ons in the callee func'on also in the calling
func'on
• rapidly accessing big data, since we copy its address as opposed
to its value

Passing by address
However:
• The code is diﬃcult to read
• We should manage the edge case where we pass nullptr

Passing by address
Upsides/downsides:
• We cannot pass constants or temporary data (they do not have
an address)

Iden%fiers
When declaring a variable, we need to specify its data type and
iden*fier
Both these aspects cannot be modified later on in the program

Iden%ﬁer aliases
However, C++ allows introducing addi5onal iden5ﬁers (aliases) for
a variables any5me in the code
int a = 5;
int& b = a; // b is a new identifier (alias) for a

Iden%ﬁer aliases
b is an alias for a, and its data type is int&
int a = 5;
int& b = a; // b is a new identifier (alias) for a

References
In C++, iden*ﬁer aliases are called references7
int a = 5;
int& b = a; // b is a reference to a
7
Star'ng from C++11, references have been renamed lvalue references

For a data type T, T& is the data type reference to T

Examples
int& a = b; // a is an alias for b (where b is of type int)
float& c = d // c is an alias for d (where d is of type float)
int& e = b; // e is an alias for b, hence an alias for a
int*& f = g; // f is an alias for g (where g is of type int*)

Trivia 1: what's the output?
int a = 5;
int& b = a;
b = 7;
std::cout << a;

Trivia 1: what's the output?
int a = 5;
int& b = a; // b is a new name for a
b = 7;
std::cout << a; // the output will be 7

Aliases are indis+nguishable
Once ini'alized, using either the new or the old iden'ﬁer is a
ma7er of indiﬀerence
int a = 5;
// using b is the same as using a (and vice-versa)
std::cout << b;

Aliases are indis+nguishable
That is, the reference is the referent8
int a = 5;
// using b is the same as using a (and vice-versa)
std::cout << b;
8
While holding conceptually, the C++11 specifica8on qualifies the reference and the referent as two different
en88es

& as a type constructor
As with *, also & can be intended as a type constructor

& as a type constructor
Construc)ng the type "reference to float"
• Input type: float
• Type constructor: &
• Output type: float&

Same symbol, two meanings
int a = 5;
// & is a type constructor
int& b = a;
// & is an operator
std::cout << &a;

Solving the swap problem
Can we use references to write a working version of the swap_int
func3on?

Idea: using references as parameters of swap_int

swap_int with references
void swap_int(??? x, ??? y) {
...
}

void swap_int(int& x, int& y) {
...
}

int temp = x;
x = y;
y = temp;
}

Note that the func,on body is the same as in our ﬁrst a5empt
int temp = x;
x = y;
y = temp;
}

int main() {
int a = 2;
int b = 5;
swap_int(a, b);
}

Note that we invoke swap_int as any other func3on
int main() {
int a = 2;
int b = 5;
swap_int(a, b);
}

References allow us to write swap_int in an easy and safe
manner
• Easy: we do not need to use the dereference operator *
everywhere
• Safe: the program will not compile if we try to pass nullptr or
temporary values

Passing by reference
If a func(on receives iden%ﬁer aliases in place of values, we say
that parameter are passed by reference
void swap_int(int& x, int& y);

Does it work?
int a = 5;
int& b;
b = a;

References are not assignable
References can be ini#alized, but not (re)-assigned
int a = 5;
int& b; // b is an alias for what?
b = a;

Does it work?
void countdown(int& number) {
std::cout << number << std::endl;
if (number != 0)
countdown(number - 1);
}

The compile-,me error
Here's the error:
error: invalid initialization of non-const reference of
type 'int&' from an rvalue of type 'int'

We can safely replace the term rvalue with temporary:
error: invalid initialization of non-const reference of
type 'int&' from a temporary of type 'int'

The temporary the error is referring to is number - 1
void countdown(int& number) {
if (number != 0)
}

Reference-to-const
The correct version reads:
void countdown(int const& number) {
if (number != 0)
}

Reference-to-const
Only constant references can bind to temporary values
if (number != 0)
}

Reference-to-const
This is why the input parameter number has to be of type int
const&, rather than int&
if (number != 0)
}

Does it work?
double& add(double x, double y) {
double z = x + y;
return z;
}

Dangling references
Although it compiles, the add func2on causes an undeﬁned
behavior
double z = x + y;
return z;
}

Dangling references
This is because we are returning an alias for z, which will be
destroyed as soon as we exit the func7on
double z = x + y;
return z;
}

Dangling references
In other words, the add func0on returns a dangling reference, that
is, a reference for a non-exis0ng object
double z = x + y;
return z;
}
int main() {
double r = add(5, 3);
std::cout << r;
}

Dangling references
Although this seems trivial when presented in contrived examples,
this is an easy mistake to make when wri9ng class' ge;ers and
se;ers

Bibliography
• S. B. Lippman, J. Lajoie, B. E. Moo, C++ Primer (5th Ed.)
• B. Stroustrup, The C++ Programming Language (4th Ed.)
• R. Lafore, Object Oriented Programming in C++ (4th Ed.)
• C++FAQ, SecJon 8

Pointers & References in C++

More Related Content

What's hot

Viewers also liked

Similar to Pointers & References in C++

More from Ilio Catallo

Recently uploaded

In this document

Pointers & References in C++