Pointers and References Java vs. C 18-Sep-18

Machine addresses 3FA71CF2 3FA71CF3 3FA71CF4 3FA71CF5 3FA71CF6 3FA71CF7 3FA71CF8 3FA71CF9 3FA71CFA 3FA71CFB 3FA71CFC 3FA71CFD 3FA71CFE 3FA71CFF 3FA71D00 3FA71D01 : Computer memory consists of one long list of addressable bytes A pointer is a data item that contains an address 3FA71CF6 3FA71CF6 • A reference is a data item that contains an address • C has pointers, but Java has references • So what’s the difference?

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 only to objects In C you can do integer arithmetic on pointers In Java you cannot do arithmetic on pointers

References 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

Information hiding The principle of information hiding is, informally, Every object should mind its own business To use an object, you need to know: How do you construct it? What operations does it provide? You do not need to know: How it does its job The object should not need to know: How you do your job If one kind of object knows about the “innards” of another kind of object, this is called tight coupling, and makes later modifications much harder Loose coupling is equivalent to good information hiding

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" "Mary" john name spouse mary

A more serious example + / 12 null 4 7 A binary tree representing the arithmetic expression 12/4+7 A binary tree is a data structure in which every node (object) has zero, one, or two children (references to other nodes), usually called left and right 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

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 v1 v2 What happens if Java decides to replace this Vector with a bigger one? It looks like the second reference (V2) becomes a “dangling pointer,” referring to nothing This doesn’t happen! Java protects you from this error

Vector’s secret trick A reference to a Vector is actually a reference to a reference to a Vector v2 v1 In this way, the “real” reference has to be changed in only one place, and all the other, indirect references automatically work A reference to a reference is sometimes called a handle Other Java-supplied objects that can vary in size (for example, sets, maps, hash tables) also use this trick

The End