Pointers and References

Apr 18, 2016

Machine addresses

Computer memory consists of

one long list of addressable
bytes
A pointer is a data item that
contains an address

3FA71CF6

Areferenceisadataitemthat
containsanaddress

3FA71CF6

Chaspointers,butJavahas
references

Sowhatsthedifference?

:
3FA71CF2
3FA71CF3
3FA71CF4
3FA71CF5
3FA71CF6
3FA71CF7
3FA71CF8
3FA71CF9
3FA71CFA
3FA71CFB
3FA71CFC
3FA71CFD
3FA71CFE
3FA71CFF
3FA71D00
3FA71D01

C (and C++) vs. Java

In C you can dereference (follow) a pointer

In Java you can dereference (follow) a reference
In C you can assign one pointer variable to another
In Java you can assign one reference variable to another
In C you can determine whether one pointer is larger than, equal to, or
smaller than another pointer
In Java you can determine whether one reference is equal to another reference
In C you can create a pointer to anything
In Java you can have references to objects
In C you can do integer arithmetic on pointers

References

Recall that an Abstract Data Type (ADT) has a set of

values and a set of operations on those values

Pointers and references have the same set of values (memory

addresses)
Pointers have more defined operations than references

Pointers are more flexible and more general than references

References are safer than pointers (from error or malicious misuse)
References allow automatic garbage collection (pointers dont)

A (non-abstract) Data Type also has an implementation

The implementations of pointers and references are similar

Java references carry information about the thing referenced;
in C, its up to the compiler to figure out what it can

Data structures

Basically, pointers and references are the same thing; they point
to (refer to) something else in memory
A Data Structure is a description of how data is organized in
memory

Many (not all) data structures are built from objects pointing/referring to
one another
Understanding pointers (references) is fundamental to this course

If this course were taught in C or C++ instead of Java, all the

nuts and bolts would be the same

This course is in Java, but its not about Java

You need to know how to create your own data structures
I will also teach some Java-specific packages

In real life, its stupid to redo work thats already been done for you

A trivial example

We use a lot of references in Java:

class Person {
String name;
Person spouse;
Person (String n) {
name = n;
}
}

Person john = new Person("John");

Person mary = new Person("Mary");
john.spouse = mary;
mary.spouse = john;

"John"

john
name
spouse
"Mary"

mary
name
spouse

A more serious example

A binary tree is a data

structure in which every node
(object) has zero, one, or two
children (references to other
nodes)
Arithmetic expressions can be
represented as binary trees
To evaluate an arithmetic
expression:

If it is a leaf, return its value

Otherwise, evaluate its two
subtrees, and perform the
indicated operation

12
null
null

7
null
null
4
null
null

Abinarytreerepresentingthe
arithmeticexpression12/4+7

Binary trees in Java

public class BinaryTree {

public Object value; // the information in this node
private BinaryTree leftChild;
private BinaryTree rightChild;
// Constructors and methods...

}
To make binary trees as useful as possible, we make the value in
a node an Object
As implementers of the BinaryTree class, our job is to make sure
that the structure of the binary tree is always valid

We dont really care what the user puts in the value field

Size of objects

Objects in Java have, generally speaking, a fixed size

The size of all primitives is known

Objects dont actually contain other objectsthey just
have references to other objects, and a reference is 4 bytes

So what about Vectors?

A Vector is like an array, but it gets bigger as you put things

into it
A Vector actually has two sizesits capacity, which is
how many references it can hold, and its size, which is how
many references are in it right now
When you exceed the capacity of a Vector, Java creates a new
Vector for you

The magic of Vectors

Suppose you have two

references to a Vector, and
you use one of them to add
elements to the Vector
What happens if Java decides
to replace this Vector with a
bigger one?

v1
v2

It looks like the second reference is a dangling pointer,

referring to nothing
This doesnt happen! Java protects you from this error
But how?

Vectors secret trick

A reference to a Vector is
actually a reference to a
reference to a Vector

v1
v2

In this way, the real reference has to be changed in only one

place, and all the other, indirect references automatically work
Its clever, but it isnt magic

The End