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 Pointersmust declare a pointer as pointing to a value of a particular type. type *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 #3

Dynamic Variables Dynamic Variables (DVs) are different than

normal variables in two aspects:

1. DVs are not declared (have no identifiers)

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:

ptr = new int;

this statement creates a DV of type integer and uses ptr to point to it. There is no identifier 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 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

size_t 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.

The new operator & Objects throttle *t_ptr;

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

an integer argument

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 ;

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 data[], size_t n);….double *numbers;numbers = new double[10];make_it_all_42(numbers, 10);….void make_it_all_42(double data[], size_t n){ for(size_t i=0; i<n; i++)

data[i] = 42;}

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

data[i] = 42;}

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

data[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, size_t & n);

Pointer Reference Parameters

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

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

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

}

The Bag with dynamic array The constructor of the dynamic Bag

should allocate the dynamic array that the member variable data points to.

How big the initial array size should be? that may be determined by a parameter that is passed to the constructor

The size of the bag will increase as needed.

The bag classclass bag { public: ……. private: value_type *data ; // dynamic array ptr size_type used ; // how much being used size_type capacity; // current bag

capacity };

Invariant of the dynamic bag the number of items in the bag is in the

member variable used

The items are stored in a partially filled dynamic array that is pointed to by data

The total size of the dynamic array is in the member variable capacity

Question Which function/operator are used to

increase the capacity of the bag ?

Ans: insert and the operator +=

What will happen if the initial bag size is two small ?

Ans: too many increases to memry by inset or += will slow down the execution

How capacity is increased larger memory block is allocated

(new)

items from completely used memory block (old memory) are copied to the newly allocated memory

the old memory is released

New Bag Constructor bag(size_type init_capacity = DEF_CAP); // postcondition: the bag is empty with a // capacity given by the parameter. The

insert // function will work efficiently ( without // allocating new memory ) until this // capacity is reached.

Example call: bag kilosack(1000);

The reserve function A member function that is used to adjust

a bag’s capacity void reserve(size_type new_capacity) // postcondition: the bag’s current

capacity // is changed to new_capacity. The insert // function will work efficiently ( without // allocating new memory) until newly // allocated, larger, capacity is reached

Question Name five member functions that

allocate dynamic memory for the bag ?

Ans: constructor , reserve, insert , += and +

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

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;}