Chapter 10: Pointers

Starting Out with C++

Early Objects
Seventh Edition

by Tony Gaddis, Judy Walters,

and Godfrey Muganda

Revised 2015, EL Jones, Ph.D., FAMU

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley

 Topics
10.1 Pointers and the Address Operator
10.2 Pointer Variables
10.3 The Relationship Between Arrays
and Pointers
10.4 Pointer Arithmetic
10.5 Initializing Pointers
10.6 Comparing Pointers

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-2

 Topics (continued)

10.7 Pointers as Function Parameters

10.8 Pointers to Constants and Constant
Pointers
10.9 Dynamic Memory Allocation
10.10 Returning Pointers from Functions
10.11 Pointers to Class Objects and Structures
10.12 Selecting Members of Objects
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-3
 Chapter 10 – Pointers

STOP / START HERE

Part 1 – pointers to scalars (single-valued variables)

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-4

 Pointers and the Address Operator
• A value in a program is stored in memory cell in RAM
• The location of that memory cell is called its address
(like a post-office box)
– An address is a non-negative integer
– But there are billions/trillions … of them
• For convenience, programs use variables to identify
memory cells in RAM
int num = -23; // num stored in RAM at some
// address (location).

cout << & num; // Displays that address,

// e.g., 0x4422802)

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-5

 Pointer Variables and Addresses
• Pointer variable: variable that holds only an
address
• Addresses are whole numbers, written in base-16
(digits 0-9, A-F)
– 0x10  16 0x09  9 0x0A  10
– Up to 16 “digits” – 0x128AF24

• Pointers provide an alternate way to access

memory locations

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-6

 Pointer Variables
• Definition:
int *intptr;
• Read as:
“intptr can hold the address of an int value”
or
“the variable that intptr points to has type int”
• Spacing in definition does not matter:
int * intptr;
int* intptr;
int*intptr;

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-7

 Pointer Variables
• Assignment:
int num = 25; int *intptr;
intptr = &num;
• Memory layout: num intptr
25 0x4a00
address of num: 0x4a00

• Can access num using intptr and the deference or

indirection operator *:
cout << intptr; // prints 0x4a00
cout << *intptr; // prints 25

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-8

 Deferencing Operator
• Interpretations:
int x, num = 25; int *intptr;

intptr = &num; // intptr hold address, points

// to value stored in num.
*intptr = 44; // Store 44 into the memory cell
// intptr points to.
x = * intptr; // Store the value intptr points to
// into variable (memory cell) x.
cout << intptr; // Display the address stored in intptr.
cin >> * intptr; // Read value into the memory cell intptr
// points to

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-9

 Pointers, I/O and Functions
Two ways to access x, by name, by pointer:
int x = 5; int * xp = & x;
cout << x << “ is also “ << * xp;
cin >> *xp; // Read value into the cell xp points to.
Read (xp); // Read, passing pointer to the cell.

// Read value using pointer.

void Read(int * ip)
{
cout <<< “Enter value: “; cin >> *ip;
}

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-10

 Pointers and Functions, I/O
Two ways to access x: by name, by pointer:
int x = 5; int * xp = & x;
int z;
cout << x << “ is also “ << * xp;
cin >> *xp; // Read value into the cell xp points to.
Read (xp); // Read value into the cell xp points to.
Read (&z); // Read value into variable z using its address.
// Read value using pointer.
void Read(int * iptr)
{
cout <<< “Enter value: “; cin >> *iptr;
}

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-11

 Dynamic Memory Allocation
• Pointers can be used to create variables as
needed. These “variables” can only be accessed
by pointers, not by variable name.
int * xp1, * xp2, * xp3; // Three pointers, no memory cells yet.
xp1 = new int; // xp1 points to uninitialized memory cell.
xp2 = new int(3); // xp2 points to cell containing value 3.
xp3 = xp1; // xp3 points to same cell as xp1.

cin >> *xp3; // Read value into cell xp3 points to.
// Assume value 7 was the input.
cout << *xp1 << ‘,’ << *xp2 + *xp3; // Produces output: 7,10
NOTE: The 2 “new” cells accessible ONLY via pointers.

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-12

 Releasing Dynamic Memory
• Use delete to free dynamic memory
delete dptr;
• Failure to release dynamic memory can lead to
memory leakage … program/system crashes!
xp1 = new int(4); // xp1 points to uninitialized memory cell.
xp2 = new int(3); // xp2 points to cell containing value 3.
xp3 = xp1; // xp3 points to same cell as xp1.
xp2 = new int; // xp2 points to a different cell; nothing points to the
// cell containing value 4 now.
delete xp3; // the cell xp1 pointed to is NOW GONE!
cout << *xp1; // BAD memory reference – NO SUCH memory cell!!

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-13

 Dangling Pointers and Memory Leaks
• A pointer is dangling if it contains the address of memory
that has been freed by a call to delete.
– Solution: set pointer to NULL as soon as memory is
freed.
delete xp1; // xp1 is now pointing to nothing (the cell is gone!!).
xp1 = NULL; // Make it explicit, clear.

• A memory leak occurs if no-longer-needed dynamic

memory is not freed – AND – the memory is not accessible
because nothing points to it.
– Solution:
• Free up dynamic memory after use.
• Free up dynamic memory before reassigning the pointer.

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-14

 Chapter 10 – Pointers

STOP / START HERE

Part 2 – pointers and functions

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-15

 Initializing Pointers
• Can initialize to NULL
int *ptr = NULL;
• Can initialize to addresses of other variables
int num, *numPtr = &num;
• Initial value must have correct type
float cost;
int *ptr = &cost; // won't work

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-16

 10.6 Comparing Pointers
• Relational operators can be used to
compare addresses in pointers
• Comparing addresses in pointers is not the
same as comparing contents pointed at by
pointers:
if (ptr1 == ptr2) // compares
// addresses
if (*ptr1 == *ptr2) // compares
// contents

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-17

 10.7 Pointers as Function Parameters

• A pointer can be a parameter

• Works like a reference parameter to allow
change to argument from within function
• A pointer parameter must be explicitly
dereferenced to access the contents at
that address

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-18

 Pointers as Function Parameters
Requires:
1) asterisk * on parameter in prototype and
heading
void getNum(int *ptr);
2) asterisk * in body to dereference the pointer
cin >> *ptr;
3) address as argument to the function
getNum(&num);

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-19

 Pointers as Function Parameters
void swap(int *x, int *y)
{
int temp;
temp = *x;
*x = *y;
*y = temp;
}
int num1 = 2, num2 = -3;
swap(&num1, &num2);
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-20
 10.8 Ponters to Constants and Constant
Pointers

• Pointer to a constant: cannot change the

value that is pointed at

• Constant pointer: address in pointer

cannot change once pointer is initialized

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-21

 Ponters to Constant

• Must use const keyword in pointer

definition:
const double PI = 3.14159;
const double * pp;

• Use const keyword for pointers in

function headers to protect data from
modification from within function

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-22

 Pointer to Constant – What does the
Definition Mean?

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-23

 Constant Pointers
• Defined with const keyword adjacent to variable
name:
int classSize = 24;
int * const classPtr = &classSize;
• Must be initialized when defined
• Can be a function parameter
– Initialized by argument when function is called
– Function can receive different arguments on different calls
• While the address in the pointer cannot change, the
data at that address may be changed

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-24

 Constant Pointer – What does the
Definition Mean?

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-25

 Returning Pointers from Functions
float * floatRead()
{
float x;
cin >> x;
return & x; // NO, NO.
}
// The call …
float * fp;
fp = floatRead();

Problem: floatRead local variable x is

destroyed when function completes!!
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-26
 Returning Pointers from Functions
float * floatRead()
{
float * xp = new float;
cin >> * xp;
return xp; // YES, YES.
}
// The call …
float * fp;
fp = floatRead();

Why good: Scope rules do not apply to dynamic data –

allocated cells exist till deleted.
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-27
 Returning Pointers from Functions
• Pointer can be return type of function
int* newNum();
• Function should only return a pointer
– to data that was passed to the function as an
argument
– to dynamically allocated memory
– NEVER return pointer to local variable of the
function – it goes away when function
completes!
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-28
 Chapter 10 – Pointers

STOP / START HERE

Part 2 – pointers and arrays (multi-valued variables)

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-29

 10.3 The Relationship Between
Arrays and Pointers

• Array name is starting address of array

int vals[] = {4, 7, 11};

4 7 11
starting address of vals: 0x4a00
cout << vals; // displays 0x4a00
cout << vals[0]; // displays 4

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-30

 The Relationship Between Arrays and
Pointers

• Array name can be used as a pointer

constant
int vals[] = {4, 7, 11};
cout << *vals; // displays 4
• Pointer can be used as an array name
int *valptr = vals;
cout << valptr[1]; // displays 7

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-31

 Pointers in Expressions

• Given:
int vals[]={4,7,11};
int *valptr = vals;
• What is valptr + 1?
• It means (address in valptr) + (1 * size of an int)
cout << *(valptr+1); // displays 7
cout << *(valptr+2); // displays 11
• Must use ( ) in expression

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-32

 Array Access

Array elements can be accessed in many ways

Array access Example
method
array name and [ ] vals[2] = 17;
pointer to array and [ ] valptr[2] = 17;

array name and *(vals+2) = 17;

subscript arithmetic
pointer to array and *(valptr+2) = 17;
subscript arithmetic

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-33

 Array Access

• Array notation
vals[i]
is equivalent to the pointer notation
*(vals + i)
• No bounds checking performed on array
access

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-34

 10.4 Pointer Arithmetic

Some arithmetic operators can be used with

pointers:
– Increment and decrement operators ++, --
– Integers can be added to or subtracted from
pointers using the operators +, -, +=, and -=
– One pointer can be subtracted from another by
using the subtraction operator -

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-35

 Pointer Arithmetic

Assume the variable definitions

int vals[]={4,7,11};
int *valptr = vals;
Examples of use of ++ and --
valptr++; // points at 7
valptr--; // now points at 4

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-36

 More on Pointer Arithmetic

Assume the variable definitions:

int vals[]={4,7,11};
int *valptr = vals;
Example of the use of + to add an int to
a pointer:
cout << *(valptr + 2)
This statement will print 11

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-37

 More on Pointer Arithmetic

Assume the variable definitions

int vals[] = {4,7,11};
int *valptr = vals;
Example of pointer subtraction
valptr += 2;
cout << valptr - val;
This statement prints 2: the number of
ints between valptr and val
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-38
 More on Pointer Arithmetic

Assume the variable definitions:

int vals[]={4,7,11};
int *valptr = vals;
Example of use of +=:
valptr = vals; // points at 4
valptr += 2; // points at 11

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-39

 Dynamic Memory Allocation

• Can also use new to allocate array

A = new double[25];
– Program often terminates if there is not sufficient memory

• Can then use either [ ] operator (subscripts) or pointer

arithmetic to access array
– A[5] means the same as *(A + 5)

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-40

 Releasing Dynamic Memory

• Use delete to free dynamic memory

delete dptr;
• Use delete [] to free dynamic array
memory
delete [] arrayptr;

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-41

 Chapter 10 – Pointers

STOP / START HERE

Part 3 – pointers and struct/class variables

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-42

 10.11 Pointers to Class Objects and
Structures
• Can create pointers to objects and structure
variables
struct Student {…};
class Square {…};
Student stu1;
Student *stuPtr = &stu1;
Square sq1[4];
Square *squarePtr = &sq1[0];
• Need () when using * and .
(*stuPtr).studentID = 12204;

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-43

 Structure Pointer Operator

• Simpler notation than (*ptr).member

• Use the form ptr->member:
stuPtr->studentID = 12204;
squarePtr->setSide(14);
in place of the form (*ptr).member:
(*stuPtr).studentID = 12204;
(*squarePtr).setSide(14);

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-44

 Dynamic Memory with Objects
• Can allocate dynamic structure variables
and objects using pointers:
stuPtr = new Student;
• Can pass values to constructor:
squarePtr = new Square(17);
• delete causes destructor to be invoked:
delete squarePtr;

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-45

 10.12 Selecting Members of Objects
Situation: A structure/object contains a pointer as a
member. There is also a pointer to the structure/
object.
Problem: How do we access the pointer member
via the structure/object pointer?
struct GradeList
{ string courseNum;
int * grades;
}
GradeList test1, *testPtr = &test1;

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-46

 Selecting Members of Objects

Expression Meaning
testPtr->grades Access the grades pointer in
test1. This is the same as
(*testPtr).grades
*testPtr->grades Access the value pointed at by
testPtr->grades. This is the
same as *(*testPtr).grades
*test1.grades Access the value pointed at by
test1.grades

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10-47

 Chapter 10: Pointers

Starting Out with C++

Early Objects
Seventh Edition

by Tony Gaddis, Judy Walters,

and Godfrey Muganda

Revised 2015, EL Jones, Ph.D., FAMU

Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley