#### Transcript Operating Systems 1 - University of Hertfordshire

C++ Pointers
Joseph Spring/Bob Dickerson
School of Computer Science
Operating Systems and Computer Networks
Based on notes by Bob Dickerson and Introduction to C++ Programming by Roberge and Smith
Lecture – Pointers
1
Areas for Discussion
•
•
•
•
•
•
•
•
Pointers: Introduction
Declaring Pointers
Dereferencing a Pointer
Pointer Arithmetic
Pointers and Arrays
Dynamic Memory Allocation
De-allocating Memory Allocation
Lecture – Pointers
2
Pointers: Introduction
Lecture – Pointers
3
Pointers: Introduction
• Pointers
– Are variables that holds the memory address of
a data value rather than the data value itself
– point to the data value
– Are useful for:
• Manipulating array elements
• Processing strings
• Dynamically allocating system memory
– Are declared by preceding the identifier with
the indirection operator *
Lecture – Pointers
4
Declaring Pointers
Lecture – Pointers
5
Declaring Pointers
The declaration:
int *iptr;
creates a pointer iptr that can store the
We note:
– At this stage iptr does not contain an address
– We have to assign an address to iptr
– We can assign an address by using the addressof operator &
Lecture – Pointers
6
Declaring Pointers
Example
int *iptr; //Declaring iptr as a pointer to an integer value
int num = 5;
//num contains the integer value 5
iptr = &num; //iptr now points to num
To access the value pointed to by a pointer we
can use the indirection operator *
cout << *iptr << “\n”;
Lecture – Pointers
7
Dereferencing Pointers
Lecture – Pointers
8
Dereferencing a Pointer
cout << *iptr << “\n”;
Here the indirection operator is used to:
– Output the integer value (5)
– Stored in the memory location (num)
– Pointed to by iptr
• Accessing a value pointed to by a pointer is
called dereferencing a pointer
• The * operator is referred to as the
dereferencing operator
Lecture – Pointers
9
Assigning Pointers
Lecture – Pointers
10
Assigning a Pointers contents to another Pointer
• This maybe achieved by using the
assignment operator =
int *iptrv2; //iptrv2 is a pointer to an integer value
iptrv2 = iptr //iptrv2 points to what iptr points to (num)
• The above creates a second pointer iptrv2 to
the integer variable num
Lecture – Pointers
11
Pointers and Arrays
Lecture – Pointers
12
Pointers and Arrays
• Recall an array variable is a pointer to the
first element in an array
char section[11] = “A Title”, // sample string
*strptr;
// pointer to a char in the string
strptr = section;
• Here both section and strptr point to the
first character in the array
Lecture – Pointers
13
Pointers and Arrays
section
‘A’
strptr
‘’
‘T’
‘i’
‘t’
‘l’
‘e’
‘\0’
Lecture – Pointers
14
Pointer Arithmetic
#include<iostream>
Using namespace std;
Void main() {
char section[11] = “A Title”, //sample string
*strptr; //pointer to character in string
//set strptr to point to the first character in string
strptr = section;
//display each character in the string. Stop when strptr points to the null
character at the end of the string
while(*strptr != ‘\0’) {
cout << *strptr; //output character that pointer strptr points to
strptr++; // Advance to the next character
}
cout << “\n”
}
Lecture – Pointers
15
Pointers and Arrays
section
‘A’
‘’
‘T’
‘i’
strptr points to this
‘t’
memory location
after third execution of
statement strptr++
‘l’
‘e’
‘\0’
Lecture – Pointers
16
Pointers and Arrays
section
‘A’
‘’
‘T’
‘i’
‘t’
‘l’
‘e’
‘\0’
Strptr points to this
memory location
after seventh execution
of statement strptr++
Lecture – Pointers
17
Dynamically Allocating Memory
Storage
and
De-allocating Memory Storage
Lecture – Pointers
18
Dynamically Allocating Storage
• So far we allocate space for an array at compile time.
– For example:
const int MaxLength = 11;
int num1;
double list[500];
char inputstring[MaxLength];
• Signals to the compiler to reserve enough memory for:
• A pair of integers
• An array of 500 double prcision floating type
numbers
• A string containing 11 characters
Lecture – Pointers
19
Dynamically Allocating Storage
• This approach to memory allocation is inefficient,
particularly for arrays and strings
• It is often the case that
– the size of an array is not known until run-time
– The size varies and although its maximum size may be,
say, 500 it could regularly be much smaller
• Rather than
– specifying as much memory as one might need at
compile time, thereby regularly wasting lots of memory
– better to specify the array size at run-time and
dynamically allocate memory
Lecture – Pointers
20
Dynamically Allocating Storage
• We can dynamically allocate memory space for an
array at run-time by using the new operator
list = new double [listsize]
– Allocates an array containing listsize double precision
numbers
– Assigns list to point to the array where list is of type
double*
Lecture – Pointers
21
dynamic.cpp – code fragment
....
int listsize;
//input list size
double *list; //pointer to dynamically allocated array
cout << “Enter the array size: ”; //get size of array needed
cin >> listsize;
list = new double[listsize]; //allocate an arrray of specified size
cout << “Enter the array elements: ”; //read in array elements
For(int i=0; i < listsize; i++)
cin >> list[i];
....
Lecture – Pointers
22
De-allocating Storage
• When we no longer require dynamically allocated
memory we have to de-allocate it
• This is achieved using the delete operator
delete [ ] list;
– Note use of [ ] to indicate that list points to an array not a
single double precision number
Lecture – Pointers
23
Summary
•
•
•
•
•
•
•
•
Pointers: Introduction
Declaring Pointers
Dereferencing a Pointer
Pointer Arithmetic