Pointers
Pointers
9)
9-4
Pointer Variables
9-5
Something Like Pointers: Arrays
• We have already worked with something similar to
pointers, when we learned to pass arrays as
arguments to functions.
showValues(numbers, SIZE);
9-6
Something Like Pointers : Arrays
The values parameter, in the showValues function,
points to the numbers array.
9-8
Something Like Pointers: Reference Variables
9-9
Pointer Variables
• Pointer variables are yet another way using a
memory address to work with a piece of data.
9-10
Pointer Variables
• Definition:
int *intptr;
• Read as:
“intptr can hold the address of an int”
• Spacing in definition does not matter:
int * intptr; // same as above
int* intptr; // same as above
9-11
Pointer Variables
• Assigning an address to a pointer variable:
int *intptr;
intptr = #
• Memory layout:
num intptr
25 0x4a00
address of num: 0x4a00
9-12
9-13
The Indirection Operator
• The indirection operator (*) dereferences a
pointer.
• It allows you to access the item that the
pointer points to.
int x = 25;
int *intptr = &x;
cout << *intptr << endl;
4 7 11
starting address of vals: 0x4a00
cout << vals; // displays
// 0x4a00
cout << vals[0]; // displays 4
9-17
Outline
• What is a Pointer? • Dynamic Memory
• Arrays vs. Pointers Allocation
• Pointer Arithmetic • Return Pointers from
• Initializing Pointers Functions
• Comparing Pointers • Pointers to structures
• Pointer As Function • 2-dim Dynamic Arrays
Parameters
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
9-19
Pointers & Arrays
int array[] = {1,2,3,4};
int *ptr = NULL;
ptr = array;
ptr = &array[0]; /*same as line above*/
printf("array[0] = %d\n",array[0]);
printf("*(array+1)= %d\n",*(array+1));
printf("ptr[2] = %d\n",ptr[2]);
printf("*(ptr+3) = %d\n",*(ptr+3));
What is valptr + 1?
It means (address in valptr) + (1 * sizeof(int))
cout << *(valptr+1); //displays 7
cout << *(valptr+2); //displays 11
9-22
Array Access
• Array elements can be accessed in many ways:
Array access method Example
9-23
Array Access
9-24
9-25
Outline
• What is a Pointer? • Dynamic Memory
• Arrays vs. Pointers Allocation
• Pointer Arithmetic • Return Pointers from
• Initializing Pointers Functions
• Comparing Pointers • Pointers to structures
• Pointer As Function • 2-dim Dynamic Arrays
Parameters
Pointer Arithmetic
• Operations on pointer variables:
Operation Example
int vals[]={4,7,11};
int *valptr = vals;
9-27
9-28
9-29
Outline
• What is a Pointer? • Dynamic Memory
• Arrays vs. Pointers Allocation
• Pointer Arithmetic • Return Pointers from
• Initializing Pointers Functions
• Comparing Pointers • Pointers to structures
• Pointer As Function • 2-dim Dynamic Arrays
Parameters
Initializing Pointers
• Can initialize at definition time:
int num, *numptr = #
int val[3], *valptr = val;
• Cannot mix data types:
double cost;
int *ptr = &cost; // won’t work
• Can test for an invalid address for ptr with:
if (!ptr) ...
• Take-home message:
– initialize a pointer to be NULL
– Check validity of a pointer before using
it
9-31
Outline
• What is a Pointer? • Dynamic Memory
• Arrays vs. Pointers Allocation
• Pointer Arithmetic • Return Pointers from
• Initializing Pointers Functions
• Comparing Pointers • Pointers to structures
• Pointer As Function • 2-dim Dynamic Arrays
Parameters
Comparing Pointers
• Relational operators (<, >=, etc.) 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
9-33
Outline
• What is a Pointer? • Dynamic Memory
• Arrays vs. Pointers Allocation
• Pointer Arithmetic • Return Pointers from
• Initializing Pointers Functions
• Comparing Pointers • Pointers to structures
• Pointer As Function • 2-dim Dynamic Arrays
Parameters
Pointers as Function Parameters
• A pointer can be a parameter
• Works like reference variable to allow change to
argument from within function
• Requires:
1) asterisk * on parameter in prototype and heading
void getNum(int *ptr); // ptr is pointer to an int
2) asterisk * in body to dereference the pointer
cin >> *ptr;
3) address as argument to the function
getNum(&num); // pass address of num to getNum
9-35
Example
9-36
(Program Continues)
9-37
9-38
Pointers to Constants
• If we want to store the address of a constant
in a pointer, then we need to store it in a
pointer-to-const.
9-39
Pointers to Constants
• Example: Suppose we have the following
definitions:
9-40
Pointers to Constants
• Suppose we wish to pass the payRates array to a
function? Here's an example of how we can do it.
9-41
Declaration of a Pointer to Constant
9-42
Pointers to Constant in Functions
void swap2(const int *a, const int *b){
/*cannot change value at that address*/
• Example
9-44
Constant Pointers
9-45
Constant Pointers
int num1 = 3;
int num2 = 7;
int *const ptr1 = &num1;
/*cannot change address in ptr1*/
int *ptr2 = &num2;
num1++; /*no warning*/
(*ptr1)++; /*no warning*/
ptr1 = ptr2; /*gives warning*/
Constant Pointers to Constants
• A constant pointer to a constant is:
– a pointer that points to a constant
– a pointer that cannot point to anything except
what it is pointing to
• Example:
int value = 22;
const int * const ptr = &value;
9-47
Constant Pointers to Constants
9-48
Constant Pointers
int num1 = 3, num2 = 7;
const int *const ptr1 = &num1;
/*cannot change address and cannot
change value at that address*/
int *ptr2 = &num2;
num1++; /*no warning*/
(*ptr1)++; /*gives warning*/
ptr1 = ptr2; /*gives warning*/
Outline
• What is a Pointer? • Dynamic Memory
• Arrays vs. Pointers Allocation
• Pointer Arithmetic • Return Pointers from
• Initializing Pointers Functions
• Comparing Pointers • Pointers to structures
• Pointer As Function • 2-dim Dynamic Arrays
Parameters
Dynamic Memory Allocation
• Can allocate storage for a variable while
program is running
• Computer returns address of newly allocated
variable
• Uses new operator to allocate memory:
double *dptr;
dptr = new double;
• new returns address of memory location
9-51
Dynamic Memory Allocation
• Can also use new to allocate array:
const int SIZE = 25;
arrayPtr = new double[SIZE];
• Can then use [] or pointer arithmetic to access
array:
for(i = 0; i < SIZE; i++)
*arrayptr[i] = i * i;
or
for(i = 0; i < SIZE; i++)
*(arrayptr + i) = i * i;
• Program will terminate if not enough memory
available to allocate
9-52
Character Pointers
• char array[] = "this is an array";
– Array of characters + '\0'
– Can change the characters in the array
– Cannot change the array’s address
• char *ptr = "this is a pointer";
– Points to constant characters + '\0'
– Cannot change the string constant
– Can change the pointer value
Character Pointers
#include <stdio.h>
int main(){
char a[] = "character array";
char *b = "constant array";
a=b; /*compiler error: incompatible types
in assignment*/
a[0]='C';
b[0]='A'; /*runtime error: Segmentation
Fault*/
return 0;
}
Releasing Dynamic Memory
9-55
9-56
9-57
Program 9-14 (Continued)
9-58
Notice that in line 49 the value 0 is assigned to the sales pointer. It is a good
practice to store 0 in a pointer variable after using delete on it. First, it prevents
code from inadvertently using the pointer to access the area of memory that was
freed. Second, it prevents errors from occurring if delete is accidentally called
on the pointer again. The delete operator is designed to have no effect when
used on a null pointer.
9-59
Outline
• What is a Pointer? • Dynamic Memory
• Arrays vs. Pointers Allocation
• Pointer Arithmetic • Return Pointers from
• Initializing Pointers Functions
• Comparing Pointers • Pointers to structures
• Pointer As Function • 2-dim Dynamic Arrays
Parameters
Returning Pointers from Functions
• Pointer can be the return type of a function:
int* newNum();
• The function must NOT return a pointer to a
local variable in the function.
• A function should only return a pointer:
– to data that was passed to the function as an
argument, or
– to dynamically allocated memory
9-61
From Program 9-15
9-62
Outline
• What is a Pointer? • Dynamic Memory
• Arrays vs. Pointers Allocation
• Pointer Arithmetic • Return Pointers from
• Initializing Pointers Functions
• Comparing Pointers • Pointers to structures
• Pointer As Function • 2-dim Dynamic Arrays
Parameters
A Student Structure
struct Student
{ structure tag
int studentID; structure members
string name;
short yearInSchool;
double gpa;
};
Student stu1;
cin >> stu1.studentID;
getline(cin, stu1.name);
stu1.gpa = 3.75;
11-64
Pointers to Structures
• A structure variable has an address
• Pointers to structures are variables that can
hold the address of a structure:
Student *stuPtr;
• Can use & operator to assign address:
stuPtr = &stu1;
• Structure pointer can be a function parameter
11-65
Accessing Structure Members via
Pointer Variables
• Must use () to dereference pointer variable,
not field within structure:
cout << (*stuPtr).studentID;
11-66
From Program 11-9
11-67
Outline
• What is a Pointer? • Dynamic Memory
• Arrays vs. Pointers Allocation
• Pointer Arithmetic • Return Pointers from
• Initializing Pointers Functions
• Comparing Pointers • Pointers to structures
• Pointer As Function • 2-dim Dynamic Arrays
Parameters
Two-Dimensional Arrays
• Visually like a matrix with rows and columns
• Two big questions to answer
– How to allocate a 2-dim array?
– How to de-allocate a 2-dim array?