Pointers

ACS 169

Pointers Pointer

a data type stores a memory address points to whatever the memory location

contains

A pointer is a variable that can store a memory address. The type of item pointed to by a pointer

variable is the target type.

Examples

Declaring Pointerstype *name;

Pointer Declarations: int * ptr; char *cptr; double *dptr;

Pointers int * ptr;

int v = 5;ptr = & v ;

The & operator is called the address operator

either of the following assignments will store the value of 10 in the variable v:

v = 10 ; *ptr = 10 ;

Pointers: Dereferencing cont. So far the asterisk is used in two ways:

1. int *ptr; 2. *ptr = 10 ;

the first declares the variable ptr as a pointer of type integer but it does not make it point to any memory address.

the second assigns the value 10 to the memory location pointed at by ptr. dereferencing

Question Explain each line in the following code:

int *ptr ; int number = 42 ; ptr = &number ; *ptr = 0 ; cout << *ptr <<endl ; cout << number << endl;

Pointer Graph Representation

Dereferencing

Pointers cont. Explain the following code:

int *p1 ;int *p2;

p1 = & count ; int *p2;

*p2 = *p1; p2 = p1 ;

Quiz #2

Dynamic Variables Dynamic Variables (DVs) are different

than normal variables in two aspects:

1. DVs are not declared (have no identifiers, …no variable names)

2. DVs are created during execution phase of a program and not during compilation, the keyword new is used for this purpose.

Dynamic Variables cont.Example:

int * ptr; ptr = new int;

this statement creates a DV of type integer and uses ptr to point to it. There is no identifier (name) for the variable pointed at by ptr

Dynamic Variables cont. The creation of new DVs is called

memory allocation and the allocated memory is called dynamic memory

ptr = new int;

Makes ptr point to a newly allocated integer variable from dynamic memory.

Dynamic Variables cont.

int *ptr ; ptr = new int ;*ptr = 33;

Dynamic Variables cont.

int *n;n = new int(17);

MyType *p;p = new MyType;orp = new MyType(32.0, 17);

The new operator & Objects throttle *t_ptr;

t_ptr = new throttle(50) ; calls the throttle constructor with

an integer argument

Dynamic Arrays. To declare a dynamic array use: int *ptr ; ptr = new int[10] ;

the new operator allocates a dynamic array of 10 integers and makes ptr point to its first element.

Dynamic Arrays cont. the statement:

ptr[5] = 33;

will store the value 33 as the 6th element in the array pointed to by ptr

Heap When new allocates a dynamic

variable or dynamic array, the memory comes from a location called the program’s heap (also called the free store).

bad_alloc exception is thrown when new attempts to allocate memory and fails.

Question Determine what the following code will do

int array_size ; int *numbers; cout << “how many numbers do you

have?”; cin >> array_size ; numbers = new int[array_size] ;

Answer The operator new is used to

dynamically allocate an array of size array_size that the user enters interactively.

Question Who should initialize the

components of a dynamically allocated array whose components are of a class data type ?

Ans: the default constructor will initialize all components of the array

Delete Operator It is an efficient practice to release

any heap memory that is no longer needed.

The delete operator is used in C++ to release memory to the heap that is no longer needed.

Delete operation Examples:

int *ptr;ptr = new int;…delete ptr ;ptr = NULL;

int *p;p = new int[30];…delete [] p;

Pointers as value parametersint *main_ptr;main_ptr = new int;make_it_42(main_ptr);

void make_it_42(int* my_ptr) ; { *my_ptr = 42;}

Pointers as value parameters The following function prototype:

void make_it_42(int* my_ptr) ;

the int* indicates that the parameter is of data type integer pointer.

the parameter is a value parameter because of the absence of the & operator.

Array Parametersvoid make_it_all_42( double * num, size_t n);….double *numbers;num = new double[10];make_it_all_42(num, 10);….void make_it_all_42(double * num, int n){ for(int i=0; i<n; i++)

num[i] = 42;}

void make_it_all_42(double * num, int n){ for(size_t i=0; i<n; i++)

num[i] = 42;}

void make_it_all_42(double num[], int n){ for(size_t i=0; i<n; i++)

num[i] = 42;}

Array parameters cont. A parameter that is a pointer or array

may include the const keyword. No changes to the actual parameter or the array are possible in this case

bool is_42(const int* my_ptr);double average(const double data[],

… )

Pointers Reference Parameters

Sometimes a function needs to change a pointer parameter so that the pointer points to a new location.

Example:

void alloc_doubles(double*& ptr, int & n);

Pointer Reference Parameters

void alloc_doubles(double*& ptr, int & n);

…double *numbers;int array_size;alloc_doubles(numbers, array_size);…void alloc_doubles(double*& ptr, int & n){

cin>> n;ptr = new double[n];

}

Pointer Arithmetic The only legal arithmetic operators

on pointers are adding or subtracting an integer, or subtracting one pointer from another.

Pointer Arithmetic In C++, pointer arithmetic is

automatically done in units of the pointer's underlying base type.

Adding 1 to a pointer to an array element gives a pointer to the next element - regardless of whether we have an array of ints, an array of doubles, or an array of any other type.

Pointer Arithmetic

int ar[10];

ar + i is a pionter to the ith element beyond ar

 &ar[i] is equivalent to ar + i

 ar[i] is equivalent to *(ar + i)

What is the output?int main(){

int * array;array = new int[10];

*array = 33;*(array + 3) = 14;

cout<<array[0]<<array[3];

return 0;}