C++ ProgrammingLecture 17

Pointers – Part I

The Hashemite UniversityComputer Engineering

Department

(Adapted from the textbook slides)

The Hashemite University 2

Outline

Introduction. Pointer variables. Pointer operators. Calling functions by reference. Using const with pointers. Examples.

The Hashemite University 3

Introduction

Pointers Powerful, but difficult to master. Simulate call-by-reference. Allow the creation of dynamic data

structures that shrink and grow in size during run time, such as stacks, link lists, etc.

Close relationship with arrays and strings.

The Hashemite University 4

Pointer Variable Declarations and Initialization I Pointer variables

Contain memory addresses as their values Normal variables contain a specific value (direct

reference) Pointers contain the address of a variable that has a

specific value (indirect reference) Indirection

Referencing a pointer value (accessing the contents of the memory location indicated by the address found inside the pointer).

Pointer declarations * indicates that a variable is a pointer

int *myPtr;

declares a pointer to an int, a pointer of type int * Multiple pointers require multiple asterisks

int *myPtr1, *myPtr2;

The Hashemite University 5

Pointer Variable Declarations and Initialization II

Can declare pointers to any data type

Pointers initialization Initialized to 0, NULL, or an address

0 or NULL points to nothing

The Hashemite University 6

Pointer Operators I & (address operator)

Returns the address of its operand It is different from the reference operator used in declaring

reference variables. Can be applied to variables only (cannot be applied to expressions

or constants syntax error) Example

int y = 5;int *yPtr;yPtr = &y; // yPtr gets address of y

yPtr “points to” y

yPtr

y5

yptr

500000 600000

y

600000 5

address of y is value of yptr

The Hashemite University 7

Pointer Operators II * (indirection/dereferencing operator)

Returns the value of what its operand points to *yPtr returns y (because yPtr points to y). * can be used to assign a value to a location in

memory*yptr = 7; // changes y to 7

Dereferenced pointer (operand of *) must be an lvalue (no constants)

* and & are inverses Cancel each other out

*&myVar == myVar and&*yPtr == yPtr

The Hashemite University 8

Pointer Operators III Dereferencing a variable that is not a pointer is a syntax

error, e.g.:int y = 10;cout << *y; //syntax error

Dereferencing a null-pointer is a fatal error (i.e. you program will abort abnormally).

The content of a pointer (which is a memory address) is expressed in hexadecimal when you print it on the screen. Some compilers may print it in decimal (machine dependent).

You can change the address within the pointer during the program (i.e. you can change the variable to which the pointer is pointing).

You must initialize the pointer with the address of a variable with the same data types as the pointer. e.g.:int *p;double y = 10;P = &y; //Syntax error

The Hashemite University 9

1 // Fig. 5.4: fig05_04.cpp2 // Using the & and * operators3 #include <iostream>45 using std::cout;6 using std::endl;78 int main()9 {10 int a; // a is an integer11 int *aPtr; // aPtr is a pointer to an integer1213 a = 7;14 aPtr = &a; // aPtr set to address of a1516 cout << "The address of a is " << &a17 << "\nThe value of aPtr is " << aPtr;1819 cout << "\n\nThe value of a is " << a20 << "\nThe value of *aPtr is " << *aPtr;2122 cout << "\n\nShowing that * and & are inverses of "23 << "each other.\n&*aPtr = " << &*aPtr24 << "\n*&aPtr = " << *&aPtr << endl;25 return 0;26 }

The address of a is the value of aPtr.

The * operator returns an alias to what its operand points to. aPtr points to a, so *aPtr returns a.

Notice how * and & are inverses

The address of a is 006AFDF4The value of aPtr is 006AFDF4The value of a is 7The value of *aPtr is 7Showing that * and & are inverses of each other.&*aPtr = 006AFDF4*&aPtr = 006AFDF4

The Hashemite University 10

Calling Functions by Reference Call by reference with pointer arguments

Pass address of argument using & operator Allows you to change actual location in memory Arrays are not passed with & because the array name

is already a pointer contains the address of the first element of the array in the memory.

* operator used as alias/nickname for variable inside of function

void doubleNum( int *number ) { *number = 2 * ( *number );}

*number used as nickname for the variable passed in When the function is called, must be passed an

address doubleNum( &myNum );

The Hashemite University 11

1 // Fig. 5.7: fig05_07.cpp2 // Cube a variable using call-by-reference 3 // with a pointer argument4 #include <iostream>56 using std::cout;7 using std::endl;89 void cubeByReference( int * ); // prototype1011 int main()12 {13 int number = 5;1415 cout << "The original value of number is " << number;16 cubeByReference( &number );17 cout << "\nThe new value of number is " << number << endl;18 return 0;19 }2021 void cubeByReference( int *nPtr )22 {23 *nPtr = *nPtr * *nPtr * *nPtr; // cube number in main24 }

Inside cubeByReference, *nPtr is used (*nPtr is number).

The original value of number is 5The new value of number is 125

Notice how the address of number is given - cubeByReference expects a pointer (an address of a variable).

The Hashemite University 12

Using the const Qualifier with Pointers I

const qualifier: Variable cannot be changed. const used when function does not need to change a

variable. Attempting to change a const variable is a syntax error.

const pointers: Point to same memory location during the whole

program, i.e. the pointer cannot be modified to point to other data.

Must be initialized when declaredint *const myPtr = &x;

Pointer points to const data: Means that the data cannot be modified indirectly (i.e.

through the pointer) by dereferencing the pointer.

The Hashemite University 13

Using the const Qualifier with Pointers II Types of const pointers:

Non-constant pointer to a non-constant datae.g.: int *myPtr = &x;

Constant pointer to a non-constant data: default for array names

e.g.: int *const myPtr = &x;

Non-constant pointer to a constant datae.g.: const int *myPtr = &x;

Constant pointer to a constant datae.g.: const int *const myPtr = &x;

The Hashemite University 14

1 // Fig. 5.13: fig05_13.cpp

2 // Attempting to modify a constant pointer to

3 // non-constant data

4 #include <iostream>

5

6 int main()

7 {

8 int x, y;

9

10 int * const ptr = &x; // ptr is a constant pointer to an

11 // integer. An integer can be modified

12 // through ptr, but ptr always points

13 // to the same memory location.

14 *ptr = 7;

15 ptr = &y;

16

17 return 0;

18 }

Error E2024 Fig05_13.cpp 15: Cannot modify a const object in function main()

Changing *ptr is allowed - x is not a constant.

Changing ptr is an error - ptr is a constant pointer.

The Hashemite University 15

Additional Notes

This lecture covers the following material from the textbook: Chapter 5: Sections 5.1 – 5.5