1. Review of pointers and dynamic objects

2. Memory Management  Static Memory Allocation  Memory is allocated at compiling time  Dynamic Memory  Memory is allocated at running time { int a[200]; … } { int n; cin >> n; a[n]??? }

3. Static vs. Dynamic Objects  Static object  Memory is acquired automatically  Memory is returned automatically when object goes out of scope  Dynamic object  Memory is acquired by program with an allocation request  new operation  Dynamic objects can exist beyond the function in which they were allocated  Object memory is returned by a deallocation request  delete operation

4. Why pointers? Dynamic objects are ‘implemented’ or ‘realized’ by ‘pointers’ which are parts of low-level ‘physical memory’ We don’t like it, but can not avoid it. Low level languages directly manipulate them High level languages want to ‘hide’ the pointers (conceptually remove them)

5. Pointers  A pointer is a variable used for storing the address of a memory cell.  We can use the pointer to reference this memory cell 100 ……1024… Memory address:1024 10032 … 1020 Integer a Pointer p int a; int* p; a

6. Getting an address: address operator & int a=100; “&a”  “the address of a” 100………… Memory address:1024 int a = 100; cout << a;  100 Cout << &a;  1024 … 1020 a

7. Dereferencing Operator *  We can access to the value stored in the variable pointed to by preceding the pointer with the “star” operator (*), 10088…1024… Memory address:102410032 … 1020 int a = 100; int* p = &a; cout << a << endl; cout << &a << endl; cout << p << " " << *p << endl; cout << &p << endl; a p *p gives 100

8. Pointer to pointer … int a; int* p; int** q; a = 58; p = &a; q = &p; a pq 58 a, *p, and **q are the same object whose value is 58! But q = &a is illegal!

9. An asterisk (‘*’) has two usages  In a definition, an asterisk indicates that the object is a pointer. char* s; // s is of type pointer to char (char *s; is possible)  In expressions, an asterisk before a pointer indicates the object the pointer pointed to, called dereferencing int i = 1, j; int* ptr; // ptr is an int pointer ptr = &i; // ptr points to i j = *ptr + 1;// j is assigned 2 cout << *ptr << j << endl; // display " 12 "

10. Writing pointer type properly in C++ … int *a, *b; a, b are both integer pointers int* a, b; a is integer pointer, b is just integer! typedefine int* IntPt; IntPt a, b; typedefine int MyInt; MyInt k; int k; int* a; int* b; ? Recommended!!! I don’t like this!

11. Summary * has two usages: - pointer type definition: int a; int* p; - dereferencing: *p is an integer variable if p = &a; & has two usages: - getting address: p = &a; - reference: int& b a; b is an alternative name for a First application in passing parameters (‘swap’ example) int a=10; int b=100; int* p; int* q; P = &a; Q = &b; p = q; *p = *q; ? ?

12. Pointers and References Reference (implemented as a (const) pointer) is an abstraction, Not available in C, only in C++.

13.  A pointer can be assigned a new value to point at a different object, but a reference variable always refers to the same object. Assigning a reference variable with a new value actually changes the value of the referred object. int* p; int m = 10; int& j = m; //valid p = &m; //p now points at m int n = 12; j = n; //the value of m is set to 12. But j still refers to m, not to n. cout << “value of m = “ << m <<endl; //value of m printed is 12 n = 36; Cout << “value of j = “ << j << endl; //value of j printed is 12 p = &n; Pointer vs. Reference

14.  A reference variable is different from a pointer int x=10; int* ref; Ref = &x; int x=10; int& ref = x; x ref 10 int& ref; 10 x ref

15.  A constant reference variable v refers to an object whose value cannot be changed through v. int m = 8; const int& j = m; m = 16; //valid j = 20; //compilation error

16. Traditional Pointer Usage void swap(char* ptr1, char* ptr2){ char temp = *ptr1; *ptr1 = *ptr2; *ptr2 = temp; } int main() { char a = 'y'; char b = 'n'; swap(&a, &b); cout << a << b << endl; return 0; } Uese pass-by-value of pointers to ‘change’ variable values C language does not have ‘call by reference’!

17. Pass by Reference (better than ‘pointers’) void swap(char& y, char& z) { char temp = y; y = z; z = temp; } int main() { char a = 'y'; char b = 'n'; swap(a, b); cout << a << b << endl; return 0; } y, z are ‘references’, only names, not like ptr1, ptr2 that are variables

18. Pointers and Arrays Double faces of an array: int a[10] l a is the name of an array, l a is also is a constant pointer to its first element

19. Pointers and Arrays The name of an array points only to the first element not the whole array. 2 4 8 6 22 a[4] a[0] a[2] a[1] a[3] a

20. Result is: 2 #include Using namespace std; void main(){ int a[5] = {2,4,6,8,22}; cout << *a << " " << a[0] << " " << *(&a[0]);..." } //main 2 4 8 6 22 a[4] a[0] a[2] a[1] a[3] Dereference of an array name This element is called a[0] or *a

21. To access an array, any pointer to the first element can be used instead of the name of the array. We could replace *p by *a #include Using namespace std; void main(){ int a[5] = {2,4,6,8,22}; int* p = a; int i = 0; cout << a[i] << " " << *p;... } 2 4 8 6 22 a[4] a[0] a[2] a[1] a[3] a p a Array name as pointer 2 2

22. Pointers and constants  A pointer: two objects, pointer and the object pointed to  const int* i=10; pointer to a constant  Int *const j=20; constant pointer  const int *const k=10; const pointer to const

23. dynamic objects

24. Static variables (objects)Dynamic variables (objects) A (direct) named memory locationA static part (pointer) + (indirect) nameless memory location (dynamic part) int a; a = 20; int* pa; pa = new int; *pa = 20; 20 a pa static dynamic Summary

25. int* p = new int; *p = 10; delete p; p 10 p int* p = new int[100]; for (i=1;i<100,i++) p[i] = 10; delete [] p; Simple dynamic variable Dynamic array ‘delete p’ is not sufficient for an array!!! ‘delete’ two actions: 1. Return the object pointed to 2. Point the pointer p to NULL 10

26. A Simple List Example: using a dynamic array  concept of a list, e.g. a list of integers  Print out info  Empty test  Search an element  Insertion (at head, at end, any position)  Deletion  …  implemented  by a static array (over-sized if necessary) int list[1000]; int size;  by a dynamic array int list[size]; int size;  by a linked list and more …

27. int main() { cout << "Enter list size: "; int n; cin >> n; int* A = new int[n]; initialize(A, n, 0); print(A, n); A = addEnd(A,n,5); print(A, n); A = addHead(A,n,5); print(A, n); A = deleteFirst(A,n); print(A, n); selectionSort(A, n); print(A, n); delete [] A; } How to use a list? int A[10000]; int n; Nothing compulsary in programming, only style matters!

28. Initialize void initialize(int list[], int size, int value){ for(int i=0; i<size; i++) list[i] = value; }

29. void print(int list[], int size) { cout << "[ "; for(int i=0; i<size; i++) cout << list[i] << " "; cout << "]" << endl; } Print out a list

30. Delete the first element // for deleting the first element of the array int* deleteFirst(int list[], int& size){ int* newList; newList = new int[size-1]; // make new array if(size){// copy and delete old array for(int i=0; i<size-1; i++) newList[i] = list[i+1]; delete [] list; } size--; return newList; }

31. Instead of A = deleteFirst(A,n) we can also just deleteFirst(A,n) if we define as a void type function: void deleteFirst(int*& A, int& size) { … A = newList; } Remark:

32. Adding Elements // for adding a new element to end of array int* addEnd(int list[], int& size, int value){ int* newList; newList = new int [size+1]; // make new array if(size){// copy and delete old array for(int i=0; i<size; i++) newList[i] = list[i]; delete [] list; } newList[size] = value; size++; return newList; }

33. // for adding a new element at the beginning of the array int* addHead(int list[], int& size, int value){ int* newList; newList = new int [size+1]; // make new array if(size){// copy and delete old array for(int i=0; i<size; i++) newList[i+1] = list[i]; delete [] list; } newList[0] = value; size++; return newList; } Add at the beginning: