DYNAMIC ARRAYS; FUNCTIONS & POINTERS; SHALLOW VS DEEP COPY

Size: px

Start display at page:

Download "DYNAMIC ARRAYS; FUNCTIONS & POINTERS; SHALLOW VS DEEP COPY"

Augustine Martin
6 years ago
Views:

1 DYNAMIC ARRAYS; FUNCTIONS & POINTERS; SHALLOW VS DEEP COPY Pages 800 to 809 Anna Rakitianskaia, University of Pretoria

2 STATIC ARRAYS So far, we have only used static arrays The size of a static array must be fixed at compile time: int array[10]; // create a 10-element array The following is illegal with a static array: cout << "How many variables do you want? "; int nvars; cin >> nvars; int array[nvars]; // wrong! // The size of the array must be a constant How would you choose array size at run time?

3 DYNAMIC ARRAYS Dynamic arrays are allocated on the heap using the new keyword: int *arrayptr = new int[10]; // create a 10-element array dynamically The following is possible now: cout << "How many variables do you want? "; int nvars; cin >> nvars; int *array = new int[nvars]; // correct! Pointer array now points to the first element of the array we have just created

4 ARRAYS & POINTER ARITHMETIC Both static and dynamic array variables store the address of the first array element Static: int array[5]; Dynamic: int *array = new int[5]; array 1000 address array[0] 1000 array[1] 1004 array[2] 1008 array[3] 1012 array[4] 1016 memory

5 ARRAYS & POINTER ARITHMETIC Pointer arithmetic can be used to iterate through an array: const int arraysize = 7; int array[arraysize]; for (int *p = array; p < array + arraysize; p++) *p = 0; // Pointer p points at the current element; // Dereferencing p accesses the element; // Incrementing p moves p to the next el.

6 ARRAYS & POINTER ARITHMETIC Traverse a dynamic array using pointer arithmetic: int *array = new int[arraysize]; for (int *el = array; el < array + arraysize; el++) *el = 0; // set every element to 0 Traverse a dynamic array using subscripts: int *array = new int[arraysize]; for (int i = 0; i < arraysize; i++) array[i] = 0; // set every element to 0 The subscript access to dynamic array elements is implemented using pointer arithmetic: array[ i ] == * ( array + i )

7 DYNAMIC TWO-DIMENSIONAL ARRAYS Static two-dimensional: int a[3][3]; a[0][0] a[0][1] a[0][2] a[1][0] a[1][1] a[1][2] a[2][0] a[2][1] a[2][2] Dynamic two-dimensional: a dynamic array of dynamic arrays (a pointer to an array of pointers) memory array[0] * a[0][0] a[0][1] a[0][2] array[1] * a[1][0] a[1][1] a[1][2] array[2] * a[2][0] a[2][1] a[2][2]

8 DYNAMIC TWO-DIMENSIONAL ARRAYS To declare a two dimensional array, we first declare an array of pointers (rows), and then declare every row to be an array of columns: int **a = new int * [3]; // rows for(int row = 0; row < 3; row++) a[row] = new int[3]; // columns memory a 1000 a[0] * a[0][0] a[0][1] a[0][2] a[1] * a[1][0] a[1][1] a[1][2] a[2] * a[2][0] a[2][1] a[2][2]

9 DYNAMIC TWO-DIMENSIONAL ARRAYS Individual elements of a 2D dynamic array can still be accessed through double indices: for(int row = 0; row < 3; row++) for(int col = 0; col < 3; col++) cout << a[row][col] << endl; To deallocate all pointers, you have to loop through the array: for(int row = 0; row < 3; row++) delete [] a[row]; delete [] a;

10 DYNAMIC TWO-DIMENSIONAL ARRAYS Standard main function signature: int main(int argc, char** argv)... argc number of command line parameters argv an array of parameters, where every parameter is an array of characters./test param1 param2 param3

11 POINTERS & FUNCTIONS Pass by value Pass by reference void dostuff(int x) x++; int y = 42; dostuff(y); cout << y << endl; // The output is 42 : // y has not being // modified void dostuff(int &x) // Notice the & x++; int y = 42; dostuff(y); cout << y << endl; // The output is 43 : // y has being modified!

12 POINTERS & FUNCTIONS Pointer parameter: Pass by value void dostuff(int * x) *x = 42; // *x can be modified, // but x (address) can // not be modified Pointer parameter: Pass by reference void dostuff(int * &x) *x = 42; x = NULL; // Both *x and x // can be modified Pass by pointer: Even though the pointer address can not be modified when a pointer is passed by value, the value of the memory location to which the pointer points can still be modified thus, passing a pointer by value is similar to passing the value that it points to by reference

13 POINTERS & FUNCTIONS Pass by pointer Pass by reference void dostuff(int *x) (*x)++; int y = 42; dostuff(&y); cout << y << endl; // The output is 43 : // y has being modified! void dostuff(int &x) x++; int y = 42; dostuff(y); cout << y << endl; // The output is 43 : // y has being modified!

14 POINTERS & FUNCTIONS Return type of a function can be a pointer: we might want to return the address, not the value However, returning an address of a local variable will result in an error: int* multbytwo(int n) int nvalue = n * 2; int *p = &nvalue; // get the address of nvalue return p; // return the pointer // nvalue goes out of scope here! // Our pointer is useless now...

15 POINTERS & FUNCTIONS Pointers to dynamically allocated memory can be safely returned: dynamic variables have no scope Useful example: returning a dynamic array int* allocatearray(int nsize) int *x = new int[nsize]; return x; int main() int *array = allocatearray(25); // do stuff with array delete[] array; return 0;

memory Deep Copy Make a copy of the data and assign this data to a new variable Two

16 SHALLOW VS DEEP COPY & POINTERS Shallow Copy Copy the address of one variable into another variable Two variables refer to the same data stored in the same location in memory Deep Copy Make a copy of the data and assign this data to a new variable Two variables refer to two different locations in memory where the same data is stored x y data x y data data

17 SHALLOW COPY & POINTERS Assigning a pointer to another pointer creates a shallow copy: int *first = new int[nsize]; // fill array with data int *second = first; // now both first and second store the same address, // but the array is stored in memory once:

18 SHALLOW COPY & POINTERS If we delete either of the two pointers, both will be dangling: delete [] second; // The data has been deleted, // even though first still points to it!

19 DEEP COPY & POINTERS To make a deep copy of an array, iterate through it: int *first = new int[nsize]; // fill array with data int *second = new int[nsize]; for(int i = 0; i < nsize; i++) second[i] = first[i];

20 QUESTION TIME Next lecture: Classes & pointers

INITIALISING POINTER VARIABLES; DYNAMIC VARIABLES; OPERATIONS ON POINTERS

INITIALISING POINTER VARIABLES; DYNAMIC VARIABLES; OPERATIONS ON POINTERS Pages 792 to 800 Anna Rakitianskaia, University of Pretoria INITIALISING POINTER VARIABLES Pointer variables are declared by putting