Pointers and References
Timothy Budd
3/24/2016
C++ for Java Programmers
1
Java Primitive & Reference Types
Primitive types:
Numeric – byte, short, long, float, double
Boolean
Char
Reference types:
String
Array
Class
3/24/2016
C++ for Java Programmers
2
Java Primitive & Reference Types
Primitive type variables contain the values of
the things they represent.
27
int x;
x
Reference type variables contain references to
(addresses of) the objects they represent.
box
box b;
b
box data
3/24/2016
C++ for Java Programmers
3
Pointers



Powerful Objected-Oriented mechanisms
are possible due to the indirection provided
through the use of pointer values.
Often it is said that Java has no pointers,
actually, everything is represented
internally by pointer values.
In C++, the use of pointers is explicit and
must be directly manipulated in code.
3/24/2016
C++ for Java Programmers
4
Java Pointers
class box {
// Java box
public int value;
}
box a = new box();
a.value = 7;
// set variable a
box b;
b = a;
 Because both a and b internally reference
the same value, changes to either a or b
will be reflected in the other variable.
3/24/2016
C++ for Java Programmers
5
a
new box()
a
new box()
b
3/24/2016
C++ for Java Programmers
6
C++ Primitive & Reference Types
Primitive types:
Numeric – byte, short, long, float, double
Boolean
Char
Class & Struct
Reference types:
Array
String (simple strings implemented by arrays)
3/24/2016
C++ for Java Programmers
7
Pointers on Pointers


A pointer is simply a variable that holds as its
value the address of another location in memory.
The reasons for using pointer values



3/24/2016
A single pointer variable must reference a variety of
different values over the course of execution.
A pointer will reference only a single value, but the
particular value it will reference cannot be known at
compile time or at the beginning of execution.
The amount of memory necessary to hold a value
cannot be determined at compile time, and must be
allocated a run-time.
C++ for Java Programmers
8
Pointers on Pointers
p
3/24/2016
*p
C++ for Java Programmers
9
Null Pointer



A null pointer is a value that does not
reference any other memory location.
A null pointer is analogous to an
uninitialized variable in Java.
A pointer can be tested for equality to the
value zero or the constant NULL to
determine whether it is a null pointer.
3/24/2016
C++ for Java Programmers
10
4 Principal Mechanisms




Can be explicitly dereferenced using the unary * operator. If
p is a variable holding a pointer to a value, then *p is the
value addressed by the pointer.
A pointer to a structure, or class, can combine pointer
dereferencing and member field extraction using the pointer
operator. p  x is the same as (*p).x
Can be subscripted ( p[5] ) Useful only if the pointer
addresses an array of objects. The index is used to determine
the element accessed by the expression.
An integer value can be added to or subtracted from a pointer
in order to yield a new pointer (p + 5) This use assumes that
the pointer references an array of values.
3/24/2016
C++ for Java Programmers
11
The Address-of Operator

The address-of operator converts a name into a
pointer.
int i; // location for final value
int *p; // pointer variable
p = & i; // set p to point to i
scanf("%d", p);

// scan number into I
Address-of operator can be applied directly in
arguments.
int i; // location for final value
scanf("%d", &i);
// scan number into i as above
3/24/2016
C++ for Java Programmers
12
Pointers to Simple Values

Two major operations when a pointer is
referencing a primitive

To dereference the pointer value
int i = 7;
int j = 11;
int *p = & i; // set p to point to i
int *q = & j; // set q to point to j
*p = *p + 3; // i now has the value 10

Change pointer value to another pointer value
p = q;

// i now has the value 10
Pointers should be compared only for equality.
if (p == q) …
3/24/2016
while (p !=q) …
C++ for Java Programmers
13
Pointers on Simple Values

Difference between modifying a pointer
value and modifying the value that a
pointer refers to.
p = & j; // change p to point to j
p = q; // now p points to different object
3/24/2016
C++ for Java Programmers
14
Referencing a deleted value
Nothing prevents a pointer from referencing a deleted value.
int * p;
// global pointer variable
void Set () {
int i; // local variable
i = 7; // give i a value (Note: i is local)
p = & i; // set p to point to it
}
void Use () {
double d;
d = 3.0;
d += *p; // use the value p points to ??????
// i no longer exists, memory recycled
}
3/24/2016
C++ for Java Programmers
15
Value vs. Reference Parameters
Pass by Value
// statement in main()
swap(x, y);
Pass by Reference
// statement in main()
swap(x, y);
void swap (int a, int b)
{ int temp;
temp = a;
a = b;
b = temp;
}
void swap (int &a, int &b)
{ int temp;
temp = a;
a = b;
b = temp;
}
3/24/2016
C++ for Java Programmers
16
Value vs. Reference Parameters




Pass by Value
Copy of actual parameter is
passed to function
Variable, constants,
expressions can be passed
Modifying parameter affects
only local copy
Safe–no external side effects
Inefficient for large
structures (must make local
copy)
3/24/2016




Pass by Reference
Address of actual parameter
is passed to function
Only variables (things with
addresses can be passed
Modifying parameter affects
the original variable
External side effects
Efficient for large structures
(only address is passed)
C++ for Java Programmers
17
C has only value parameters
(but you can cheat)
Pass by Reference
// statement in main()
swap(x, y);
Pass by Reference (sort of)
// statement in main()
swap(&x, &y);
void swap (int &a, int &b)
{ int temp;
temp = a;
a = b;
b = temp;
}
void swap (int *a, int *b)
{ int temp;
temp = *a;
*a = *b;
*b = temp;
}
3/24/2016
C++ for Java Programmers
18
C has only value parameters
(Ooops – except for arrays)




Arrays are always passed by reference
Saves time & space
Array names are base addresses
int a[100];
a == &a[0];
Java has only value parameters … but
when passing a reference type you are actually
passing the reference (address) by value
so it works just like “call by reference”
3/24/2016
C++ for Java Programmers
19
Pass by Reference Parameters

The most common use of reference is in
parameter passing. A reference parameter is an
alias for the corresponding actual argument value.
void passTest (int & i) {
i++;
i = 7;
}
int main ( ) {
int j = 5;
passTest(j);
cout << j << '\n';
return 0;
}
3/24/2016
C++ for Java Programmers
20
Pointers to Pointers

A pointer to a value that is itself a pointer
can be declared using multiple levels of
* symbols.
int main (int argc, char ** argv)
{
...
cout << "name of program " << **argv << '\n';
return 0;
}
3/24/2016
C++ for Java Programmers
21
Pointers and const

Modifier const indicates whether it is the
pointer itself or the value it points to that is
constant.
int i = 7;
const int * p = &i; // pointer to a constant int
int * const q = &i; // constant pointer
*p = 8;
*q = 8;
p = q;
q = p;
3/24/2016
// not allowed, p points to a const int
// allowed, q is pointing to non const int
// allowed, p itself is not constant
// not allowed q is constant
C++ for Java Programmers
22
void * Pointers

A void pointer can reference any type of
value.
double d;
double * dp = & d;
void * p = dp;

A void * parameter must always be cast
before it can be used.
double * dp2;
dp2 = (double *) p; // convert p back into pointer to double
3/24/2016
C++ for Java Programmers
23
Pointers to Functions

A function pointer can be invoked
without the deference operator.
double fdiv (int i, int j) { return i / (double) j; }
double (*fptr) (int, int); // declare variable fptr
fptr = & fdiv; // assign value
double x = fptr(7, 14); // call ftpr directly
double x = (*fptr) (7, 14); // dereference ftpr and call
3/24/2016
C++ for Java Programmers
24
Pointers to Functions
double values[100];
int comp (void * a, void * b)
{
double * d1 = (double *) a;
double * d2 = (double *) b;
return (*d1) < (*d2);
}
qsort (values, 100, sizeof(double), &comp);

Avoid qsort in code; use the STL routines
instead.
3/24/2016
C++ for Java Programmers
25
Pointers to Structure

The arrow operator is a combination of
dereferencing and field access.
struct link {
int value;
link * next; // pointer to next link in chain
};
link finalElement; // declare a single default element
link * firstLink = & finalElement;
// set pointer to initially refer to this
(*firstLink).value = 7; // these two statements
firstLink->value = 7; // have the same effect
3/24/2016
C++ for Java Programmers
26
Pointers to Structure
for (link *p = aList; p != &finalElement;
cout << p -> value << " ";
3/24/2016
C++ for Java Programmers
p = p->next)
27
Pointers to Arrays

Pointers can be subscripted just like arrays.
int values[100];
int * p = values;
// legal, as values is converted into a pointer
p[4] = 7; // references same value as values[4]

Neither pointer not array index values are
checked to ensure they are in range.
p[310] = 7; // index value too large
p[-4] = 12; // index value too small
3/24/2016
C++ for Java Programmers
28
Pointer Arithmetic

It is legal to perform arithmetic on pointers.
char * text = " ... some text ";
// p++ advances pointer to next location
for (char * p = text; *p != '\0'; p++)
if (isVowel(*p))
cout << "vowel value is " << *p << "\n";
3/24/2016
C++ for Java Programmers
29
Reference


A reference is an alias, an alternative way
to name an existing object.
Difference between reference and pointers




3/24/2016
A reference can never be null; it must always refer to
a legitimate object.
Once established, a reference can never be changed
to make it point to a different object.
A reference does not require any explicit mechanism
to dereference the memory address and access the
actual data value.
A pointer is a variable that can contain a reference
C++ for Java Programmers
30
References

A reference is declared by using the ampersand.
int i = 7;
int & j = i;
// j is an alias for i
j++;
// i is now 8
i += 3; // i is now 11, as is j

A reference can be target of an assignment.
Some functions will return a reference as a result
for precisely this reason.
int values[100];
int & index(int i) {
return values[i + 2];
}
index(27) = 12; // changes values[29];
3/24/2016
C++ for Java Programmers
31
Pass by Reference Parameters

The most common use of reference is in
parameter passing. A reference parameter is an
alias for the corresponding actual argument value.
void passTest (int & i) {
i++;
}
int main ( ) {
int j = 5;
passTest(j);
cout << j << '\n';
return 0;
}
3/24/2016
C++ for Java Programmers
32
Pass by Reference Parameters

None of the parameter passing options in C++
matches the Java semantics.
static void passTest (box i)
{
i.value++;
i = new box(7);
}
public static void main (String [ ] args)
{
box j = new box(5);
passTest(j);
System.out.println("J is " + j.value);
}
3/24/2016
C++ for Java Programmers
33
References as Results


References can also be used as a result type for a
function.
2 reasons for doing so:


3/24/2016
A reference can be used as the target of an
assignment. Therefore, a function call that returns a
reference can be used on the left side of an
assignment.
Returning a reference is more efficient than returning
a value. Therefore, large structures can be returned
by reference.
C++ for Java Programmers
34
Example of Reference as Result
class string { …..
char & operator [ ] (unsigned int index)
{ return buffer[index]; } ……
private:
char * buffer;
};
string text = "name:";
text[0] = 'f'; // change “name” to “fame”
3/24/2016
double & min (double data[ ], int n)
{
double minVal = data[0];
for (int i = 1; i < n; i++)
if (data[i] < minVal)
minVal = data;
return minVal; // danger, reference to local
which will soon be recycled
}
C++ for Java Programmers
35