Data Structures in C++ Pointers & Dynamic Arrays Shinta P.

Static and Dynamic Memory Static Allocation – allocated by the compiler at compile time – once allocated, does not change Dynamic Allocation – allocated by program at run time – ‘new’ allocates desired amount from heap amount depends on class/type – ‘delete’ deallocates an object and returns to storage manager for reallocation

Where or When Static – data stricture sizes are fixed – little chance for storage needs to grow – prototypes Dynamic – amount of data changes from run to run – data relationships change frequently

Pointers a built-in primitive type; 32 bit used to hold the storage address of a variable to define a pointer variable – use the * operator in the definition eg. int *airplane_ptr ; (airplane_ptr is a variable that will point to an integer) (airplane_ptr is a variable that will point to an integer)

Pointers (cont.) To assign a value to the pointer variable – use the address operator & eg. int F15; int Airplane_ptr; int Airplane_ptr; Airplane_ptr = &F15; Airplane_ptr = &F15; F15Airplane_ptr

Pointers (cont.) Note that F15 has not been assigned a value yet to do this we must use the dereferencing operator * ex. *Airplane_ptr = 5 (dereferencing * reads: location pointed to by var) (dereferencing * reads: location pointed to by var) F15Airplane_ptr 5

Pointers (cont.) Which is exactly equivalent to: F15 = 5;...so whats the big deal??

The Big Deal.... We’ve been looking at the trivial case Pointers to primitives aren’t very useful – things get more interesting with arrays we can make : – an array that grows as the application needs more room for data – an array that shrinks as the application needs less room for data – and much better with dynamic objects

More Pointers int i = 50; int j = 75; int *p1 ; int * p2 p1 = &i ; p2 = & j; cout << *p1; p1 = p2 ; *p2 =0; cout <<*p1;

Pointers to arrays The name of an array is a pointer to the 0th element of the array (the beginning of the array) int array[5] ; // array is equivalent to & array[0] *array = 5; is like array[0] = 5; int j = *(array+4) is like int j = array[1] cout << *array; is like cout << array[0];

Pointers to arrays Pass by reference - in C++ arrays are always pass by reference (there is no pass by value for an array) this is a big improvement over C – in C to pass an array to a function it had to be passed by passing a pointer to the beginning of the array then doing pointer arithmetic to manipulate the contentsd of the array

new returns the address of a piece of dynamically allocated storage i 75 ex. int *i; //create a pointer i = new int // get a new integer i = new int // get a new integer *i = 75 // assign it a value *i = 75 // assign it a value

Dynamic Arrays arrays can be allocated at run time double * p; int count ; cout << “how many elements? “ << “\n”; cin >> count; p = new double[count];

Dynamic Arrays You can effectively change the size of an array at run-time if it was originally allocated dynamically. … from previous example double * temp; temp = new double[20]; /* copy the contents of the old array into the new one */ for (int I=0 ; I < 10 ; I++) temp[I] = p[I]; /* dispose of the original array */ delete p; p = temp; /* now the array has twice as many elements */

Value semantics The value semantics of a class determine how values are copied from one object to another. In C++ the value semantics consist of two operations: – the assignment operator – the copy constructor The copy constructor is a constructor that creates and initializes an object to the value of another (existing) object – the copy constructor has one parameter whose type is the same as the class name Ex. Date Today; Today.month=5 ; Today.year=2000; Today.day = 21; Date Tomorrow(Today)

Copy Constructor Date :: Date(const & Date t) { month = t.month; day = t.month; year = t.year; }