Pointers

1. Pointers ACS 169

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

3. Examples • Declaring Pointerstype *name; • Pointer Declarations: • int * ptr; • char *cptr; • double *dptr;

4. 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 ;

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

6. Question • Explain each line in the following code: int *ptr ; int number = 42 ; ptr = &number ; *ptr = 0 ; cout << *ptr <<endl ; cout << number << endl;

8. Pointer Graph Representation

9. Dereferencing

10. Pointers cont. • Explain the following code: int *p1 ; int *p2; p1 = & count ; int *p2; *p2 = *p1; p2 = p1 ;

11. Quiz #2

12. Dynamic Variables • Dynamic Variables (DVs) are different than normal variables in two aspects: • DVs are not declared (have no identifiers, …no variable names) • DVs are created during execution phase of a program and not during compilation, the keyword newis used for this purpose.

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

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

15. Dynamic Variables cont. int *ptr ; ptr = new int ; *ptr = 33;

16. Dynamic Variables cont. int *n; n = new int(17); MyType *p; p = new MyType; or p = new MyType(32.0, 17);

17. The new operator & Objects • throttle *t_ptr;t_ptr = new throttle(50) ; • calls the throttle constructor with an integer argument

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

19. Dynamic Arrays cont. • the statement: ptr[5] = 33; will store the value 33 as the 6th element in the array pointed to by ptr

20. 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_allocexception is thrown when new attempts to allocate memory and fails.

21. 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] ;

22. Answer • The operator new is used to dynamically allocate an array of size array_size that the user enters interactively.

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

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

25. Delete operation • Examples: int *ptr; ptr = new int; … delete ptr ; ptr = NULL; int *p; p = new int[30]; … delete [] p;

26. Pointers as value parameters int *main_ptr; main_ptr = new int; make_it_42(main_ptr); void make_it_42(int* my_ptr) ; { *my_ptr = 42; }

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

28. Array Parameters void 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; }

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

30. 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[], … )

31. 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);

32. 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]; }

33. Pointer Arithmetic • The only legal arithmetic operators on pointers are adding or subtracting an integer, or subtracting one pointer from another.

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

35. 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)

36. What is the output? int main() { int * array; array = new int[10]; *array = 33; *(array + 3) = 14; cout<<array[0]<<array[3]; return 0; }