Download Pointers and References

Pointers and References
25-May-17
Machine addresses


Computer memory consists of
one long list of addressable
bytes
A pointer is a data item that
contains an address
3FA71CF6
• A reference is a data item that
contains an address
3FA71CF6
• C has pointers, but Java has
references
• So what’s the difference?
:
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 don’t)
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, it’s 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 it’s 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, it’s stupid to redo work that’s 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
A binary tree representing the
arithmetic expression 12/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 don’t 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 don’t actually “contain” other objects—they 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 “sizes”—its 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 doesn’t happen! Java protects you from this error
But how?
Vector’s 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
It’s clever, but it isn’t magic
The End