C++ Pointers

1. C++ Pointers Joseph Spring/Bob Dickerson School of Computer Science Operating Systems and Computer Networks Based on notes by Bob Dickerson and Introduction to C++ Programming by Roberge and Smith Lecture – Pointers

2. Areas for Discussion • Pointers: Introduction • Declaring Pointers • Dereferencing a Pointer • Pointer Arithmetic • The Address Operator • Pointers and Arrays • Dynamic Memory Allocation • De-allocating Memory Allocation Lecture – Pointers

3. Pointers: Introduction Lecture – Pointers

4. Pointers: Introduction • Pointers • Are variables that holds the memory address of a data value rather than the data value itself • point to the data value • Are useful for: • Manipulating array elements • Processing strings • Dynamically allocating system memory • Are declared by preceding the identifier with the indirection operator * Lecture – Pointers

5. Declaring Pointers Lecture – Pointers

6. Declaring Pointers The declaration: int *iptr; creates a pointer iptr that can store the address of an integer We note: • At this stage iptr does not contain an address • We have to assign an address to iptr • We can assign an address by using the address-of operator & Lecture – Pointers

7. Declaring Pointers Example int *iptr; //Declaring iptr as a pointer to an integer value int num = 5; //num contains the integer value 5 iptr = &num; //iptr now points to num To access the value pointed to by a pointer we can use the indirection operator * cout << *iptr << “\n”; Lecture – Pointers

8. Dereferencing Pointers Lecture – Pointers

9. Dereferencing a Pointer cout << *iptr << “\n”; Here the indirection operator is used to: • Output the integer value (5) • Stored in the memory location (num) • Pointed to by iptr • Accessing a value pointed to by a pointer is called dereferencing a pointer • The * operator is referred to as the dereferencing operator Lecture – Pointers

10. Assigning Pointers Lecture – Pointers

11. Assigning a Pointers contents to another Pointer • This maybe achieved by using the assignment operator = int *iptrv2; //iptrv2 is a pointer to an integer value iptrv2 = iptr //iptrv2 points to what iptr points to (num) • The above creates a second pointer iptrv2 to the integer variable num Lecture – Pointers

12. Pointers and Arrays Lecture – Pointers

13. Pointers and Arrays • Recall an array variable is a pointer to the first element in an array char section[11] = “A Title”, // sample string *strptr; // pointer to a char in the string strptr = section; • Here both section and strptr point to the first character in the array Lecture – Pointers

14. Pointers and Arrays section strptr Lecture – Pointers

15. Pointer Arithmetic #include<iostream> Using namespace std; Void main() { char section[11] = “A Title”, //sample string *strptr; //pointer to character in string //set strptr to point to the first character in string strptr = section; //display each character in the string. Stop when strptr points to the null character at the end of the string while(*strptr != ‘\0’) { cout << *strptr; //output character that pointer strptr points to strptr++; // Advance to the next character } cout << “\n” } Lecture – Pointers

16. Pointers and Arrays section strptr points to this memory location after third execution of statement strptr++ Lecture – Pointers

17. Pointers and Arrays section Strptr points to this memory location after seventh execution of statement strptr++ Lecture – Pointers

18. Dynamically Allocating Memory Storage and De-allocating Memory Storage Lecture – Pointers

19. Dynamically Allocating Storage • So far we allocate space for an array at compile time. • For example: const int MaxLength = 11; int num1; double list[500]; char inputstring[MaxLength]; • Signals to the compiler to reserve enough memory for: • A pair of integers • An array of 500 double prcision floating type numbers • A string containing 11 characters Lecture – Pointers

20. Dynamically Allocating Storage • This approach to memory allocation is inefficient, particularly for arrays and strings • It is often the case that • the size of an array is not known until run-time • The size varies and although its maximum size may be, say, 500 it could regularly be much smaller • Rather than • specifying as much memory as one might need at compile time, thereby regularly wasting lots of memory • better to specify the array size at run-time and dynamically allocate memory Lecture – Pointers

21. Dynamically Allocating Storage • We can dynamically allocate memory space for an array at run-time by using the new operator list = new double [listsize] • Allocates an array containing listsize double precision numbers • Assigns list to point to the array where list is of type double* Lecture – Pointers

22. dynamic.cpp – code fragment .... int listsize; //input list size double *list; //pointer to dynamically allocated array cout << “Enter the array size: ”; //get size of array needed cin >> listsize; list = new double[listsize]; //allocate an arrray of specified size cout << “Enter the array elements: ”; //read in array elements For(int i=0; i < listsize; i++) cin >> list[i]; .... Lecture – Pointers

23. De-allocating Storage • When we no longer require dynamically allocated memory we have to de-allocate it • This is achieved using the delete operator delete [ ] list; • Note use of [ ] to indicate that list points to an array not a single double precision number Lecture – Pointers

24. Summary • Pointers: Introduction • Declaring Pointers • Dereferencing a Pointer • Pointer Arithmetic • The Address Operator • Pointers and Arrays • Dynamic Memory Allocation • De-allocating Memory Allocation Lecture – Pointers