Chapter 11: Pointers

Size: px

Start display at page:

Download "Chapter 11: Pointers"

Garey Rodgers
6 years ago
Views:

1 Chapter 11: Pointers Christian Jacob 1 Pointer Basics What Are Pointers? Pointer Operators Pointer Expressions 14 2 Pointers and Arrays Pointer Arithmetic And Array Indexing Pointers Versus Arrays An Example Indexing of Pointers Interchangeability of Pointers and Arrays 25 3 String Constants and Pointers 26 4 Arrays of Pointers 27 5 Problems with Pointers Uninitialized Pointers The Null Pointer Convention Invalid Pointer Comparisons Forgetting to Reset a Pointer 32 TOC 1 Back

2 Chapter 11: Pointers Christian Jacob 6 Multiple Indirection Pointers to Pointers 34 TOC 2 Back

3 Pointer Basics Chapter 11: Pointers Christian Jacob 1 Pointer Basics 1.1 What Are Pointers? A pointer is a variable that contains a memory address. Very often this address is the location of another variable. The general form of a pointer variable declaration in C++ is: type *variable-name; type variable-name * the pointer s base type. It must be a valid C++ type. the name of the pointer variable the at address operator Returns the value of the variable located at the address specified by its operand. int *int_pointer; // pointer to integer float *float_pointer; // pointer to float First Back TOC 3 Notes Prev Next Last

4 Pointer Basics Chapter 11: Pointers Christian Jacob 1.2 Pointer Operators There are two special operators that are used with pointers: & : address of operator A unary operator which returns the memory address of its operand. * : value at address operator A unary operator which returns the value of the variable located at the address specified by its operand. Example: int balance; int *balptr; balptr = &balance; bal_ptr balance value First Back TOC 4 Notes Prev Next Last

5 Pointer Basics Chapter 11: Pointers Christian Jacob Example (continued): int balance, value; int *balptr; balance = 3200; // Step 1 balptr = &balance; // Step 2 value = *balptr; // Step 3 Step 1: Step 2: Step 3: 12 - bal_ptr bal_ptr bal_ptr balance value balance value balance value First Back TOC 5 Notes Prev Next Last

6 Pointer Basics Chapter 11: Pointers Christian Jacob Importance of the Base Type How does C++ know how many bytes to copy into value from the address pointed to by balptr? How does the compiler know the proper number of bytes for any assignment using a pointer? Answer: The base type of the pointer determines the type of data that the compiler assumes the pointer is pointing to. The following code fragment is incorrect: int *int_ptr; double f; //... int_ptr = &f; // ERROR Technically correct, but not recommended (using a type cast operator): int_ptr = (int *) &f; First Back TOC 6 Notes Prev Next Last

7 Pointer Basics Chapter 11: Pointers Christian Jacob Example for why to be careful about type casts with pointers: #include <iostream.h> int main() { double x, y; int *ptr; x = ; ptr = (int *) &x; // use cast to assign // double* to int* y = *ptr; cout << y; // What will this do? // What will this print? return(0); First Back TOC 7 Notes Prev Next Last

8 Pointer Basics Chapter 11: Pointers Christian Jacob Assigning Values Through a Pointer Pointers can be used on the left side of assignment statements. The following code fragment assigns a value to the location pointed to by the pointer. int *ptr; *ptr = 101; At the location pointed to by p, assign the value 101. Increment and decrement operations work on pointers, too. (*ptr)++; At the location pointed to by p, increment the value by 1. First Back TOC 8 Notes Prev Next Last

9 Pointer Basics Chapter 11: Pointers Christian Jacob Example program for assigning values through pointers: #include <iostream.h> int main() { int *ptr, num; // 1 ptr = &num; // 2 *ptr = 100; // 3 cout << num << ; (*ptr)++; // 4 cout << num << ; (*ptr)*2; // 5 cout << num << \n ; Step 1 12 *_int ptr 50 _int num - return 0; First Back TOC 9 Notes Prev Next Last

10 Pointer Basics Chapter 11: Pointers Christian Jacob Example program for assigning values through pointers: #include <iostream.h> int main() { int *ptr, num; // 1 ptr = &num; // 2 *ptr = 100; // 3 cout << num << ; (*ptr)++; // 4 cout << num << ; (*ptr)*2; // 5 cout << num << \n ; Step ptr 50 _int num - return 0; First Back TOC 10 Notes Prev Next Last

11 Pointer Basics Chapter 11: Pointers Christian Jacob Example program for assigning values through pointers: #include <iostream.h> int main() { int *ptr, num; // 1 ptr = &num; // 2 *ptr = 100; // 3 cout << num << ; (*ptr)++; // 4 cout << num << ; (*ptr)*2; // 5 cout << num << \n ; Step ptr num - return 0; First Back TOC 11 Notes Prev Next Last

12 Pointer Basics Chapter 11: Pointers Christian Jacob Example program for assigning values through pointers: #include <iostream.h> int main() { int *ptr, num; // 1 ptr = &num; // 2 *ptr = 100; // 3 cout << num << ; (*ptr)++; // 4 cout << num << ; (*ptr)*2; // 5 cout << num << \n ; Step ptr num - return 0; First Back TOC 12 Notes Prev Next Last

13 Pointer Basics Chapter 11: Pointers Christian Jacob Example program for assigning values through pointers: #include <iostream.h> int main() { int *ptr, num; // 1 ptr = &num; // 2 *ptr = 100; // 3 cout << num << ; (*ptr)++; // 4 cout << num << ; (*ptr)*2; // 5 cout << num << \n ; Step ptr num - return 0; First Back TOC 13 Notes Prev Next Last

14 Pointer Basics Chapter 11: Pointers Christian Jacob 1.3 Pointer Expressions Pointers can be used in most C++ expressions. Keep in mind to use parentheses around pointer expressions. Pointer Arithmetic Only four arithmetic operators can be used on pointers: ++, --, +, and -. Example: (assuming 32-bit integers) int *p1; // assume: p1 == 2000 p1++; 1996 byte 1 byte 2 byte 3 byte 4 p1--; 2000 byte 1 byte 2 byte 3 byte byte 1 byte 2 byte 3 byte 4 First Back TOC 14 Notes Prev Next Last

15 Pointer Basics Chapter 11: Pointers Christian Jacob Integers can be added or subtracted from pointers: You can subtract pointers of the same type from one another. You can not add pointers! However, you can add int numbers to pointers: #include <iostream.h> int main() { int i[10], *i_ptr; double f[10], *f_ptr; int x; i_ptr = i; // i_ptr points to first element of i f_ptr = f; // f_ptr points to first element of f for(x=0; x<10; x++) cout << i_ptr+x << << f_ptr+x << \n ; return 0; First Back TOC 15 Notes Prev Next Last

16 Pointer Basics Chapter 11: Pointers Christian Jacob Output: The addresses of the array elements: 4 bytes int 8 bytes double 0xeffffd9c 0xeffffd48 0xeffffda0 0xeffffd50 0xeffffda4 0xeffffd58 0xeffffda8 0xeffffd60 0xeffffdac 0xeffffd68 0xeffffdb0 0xeffffd70 0xeffffdb4 0xeffffd78 0xeffffdb8 0xeffffd80 0xeffffdbc 0xeffffd88 0xeffffdc0 0xeffffd90 First Back TOC 16 Notes Prev Next Last

17 Pointer Basics Chapter 11: Pointers Christian Jacob Pointer Comparisons Pointers may be compared using relational operators, such as!=, ==, <, and >. int main() { int num[10]; int *start, *end; start = num; end = &num[9]; while(start!= end) { cout << Enter a number: ; cin >> *start; start++; return 0; First Back TOC 17 Notes Prev Next Last

18 Pointer Basics Chapter 11: Pointers Christian Jacob Pointer Comparisons (2): using subtraction of pointers Pointers may be compared using relational operators, such as!=, ==, <, and >. int main() { int num[10]; int *start, *end; start = num; end = &num[9]; while((end - start) > 0) { cout << Enter a number: ; cin >> *start; start++; return 0; First Back TOC 18 Notes Prev Next Last

19 Pointers and Arrays Chapter 11: Pointers Christian Jacob 2 Pointers and Arrays 2.1 Pointer Arithmetic And Array Indexing In C++, using the name of an array without an index generates a pointer to the first element in the array: char str[80]; char *ptr; ptr = str; The last statement assigns the address of str[0] to ptr. Now there are two ways to access the n-th element in the array: str[n-1] or *(ptr + (n-1)) First Back TOC 19 Notes Prev Next Last

20 Pointers and Arrays Chapter 11: Pointers Christian Jacob 2.2 Pointers Versus Arrays An Example Here are two versions of a tokenizing program, a (usually) more efficient version with pointers, and a version using arrays. Tokeninzing Program: Pointer Version int main() { char str[80]; char token[80]; char *str_ptr, *tk_ptr; cout << Enter a sentence: ; gets(str); str_ptr = str;... First Back TOC 20 Notes Prev Next Last

21 Pointers and Arrays Chapter 11: Pointers Christian Jacob // Read a token at a time from the string while(*str_ptr) { tk_ptr = token; // start of token // Read characters until either a space or // the null terminator is encountered. while( *str_ptr!= && *str_ptr ) { *tk_ptr = *str_ptr; tk_ptr++; str_ptr++; if(*str_ptr) str_ptr++;// advance past space *tk_ptr = \0 ; // null terminate the token cout << token << endl; return 0; First Back TOC 21 Notes Prev Next Last

22 Pointers and Arrays Chapter 11: Pointers Christian Jacob Tokeninzing Program: Array Version #include <iostream> #include <cstdio> int main() { char str[80]; char token[80]; int i, j; cout << Enter a sentence: ; gets(str);... First Back TOC 22 Notes Prev Next Last

23 Pointers and Arrays Chapter 11: Pointers Christian Jacob // Read a token at a time from the string for(i=0; ; i++) { // Read characters until either a space or // a null terminator is encountered. for(j=0; str[i]!= && str[i]; j++, i++) token[j] = str[i]; token[j] = \0 ; // null termination cout << token << \n ; if(!str[i]) break; return 0; First Back TOC 23 Notes Prev Next Last

24 Pointers and Arrays Chapter 11: Pointers Christian Jacob 2.3 Indexing of Pointers One can not only use pointers to access array elements, but a pointer may also be indexed as if it were an array. #include <iostream> #include <cctype> int main() { char str[20] = hello tom ; char *p; int i; p = str; for(i=0; p[i]; i++) p[i] = toupper(p[i]); cout << p; return 0; First Back TOC 24 Notes Prev Next Last

25 Pointers and Arrays Chapter 11: Pointers Christian Jacob 2.4 Interchangeability of Pointers and Arrays Pointers and arrays are are strongly related in many cases. However, pointers and arrays are not completely interchangeable: int num[10]; int i; for(i=0; i<10; i++) { *num = i; num++; // ERROR -- cannot modify num num is a constant that points to the beginning of the array. Generally, an array name without an index generates a pointer to the beginning of an array, but it cannot be changed. *(num+3) = 100; // OK because num not modified First Back TOC 25 Notes Prev Next Last

26 String Constants and Pointers Chapter 11: Pointers Christian Jacob 3 String Constants and Pointers String constants appearing in program text are stored in the program s string table, which is generated at runtime. For every entry in the string table, a pointer to the string is generated. #include <iostream> int main() { char *s; s = Pointers are fun to use.\n ; cout << s; return 0; First Back TOC 26 Notes Prev Next Last

27 Arrays of Pointers Chapter 11: Pointers Christian Jacob 4 Arrays of Pointers Pointers can be arrayed like any other data type in C++. For example, to declare an array pi of 10 integer pointers, one would write: int *pi[10]; To assign the address of an integer variable called var to the third element of the pointer array, one would write: int var; pi[2] = &var; The following expression gives the value of var: *pi[2] First Back TOC 27 Notes Prev Next Last

28 Problems with Pointers Chapter 11: Pointers Christian Jacob 5 Problems with Pointers 5.1 Uninitialized Pointers The classic example of a pointer error is the uninitialized pointer: // This program is wrong. int main() { int x, *p; x = 10; *p = x; // Where does p point? return 0; First Back TOC 28 Notes Prev Next Last

29 Problems with Pointers Chapter 11: Pointers Christian Jacob 5.2 The Null Pointer Convention After a pointer is declared, but before it has been assigned, it will contain an arbitrary value. By convention, if a pointer contains the null (zero) value, it is assumed to point to nothing. float *p = 0; // p is now a null pointer Any type of pointer can be initialized to null when it is declared, thus avoiding accidental misuse of uninitialized pointers. To check for a null pointer, use an if statement: if(p) // succeeds if p is not null if(!p) // succeeds if p is null First Back TOC 29 Notes Prev Next Last

30 Problems with Pointers Chapter 11: Pointers Christian Jacob 5.3 Invalid Pointer Comparisons Making any comparisons between pointers to two different objects, not belonging to the same array, may yield unexpected results. char s[80]; char y[80]; char *p1, *p2; p1 = s; p2 = y; if( p1 < p2)... This code makes invalid assumptions about C++ s strategy of placing variables in memory. First Back TOC 30 Notes Prev Next Last

31 Problems with Pointers Chapter 11: Pointers Christian Jacob One should also never assume that two back-to-back arrays can be indexed as one: int first[10]; int second[10]; int *p, t; p = first; for(t=0; t<20; ++t) { *p = t; p++; First Back TOC 31 Notes Prev Next Last

32 Problems with Pointers Chapter 11: Pointers Christian Jacob 5.4 Forgetting to Reset a Pointer The following program displays the ASCII codes of each character in a string entered from the keyboard. This program has a serious bug! int main() { char s[80], *p1; p1 = s; do{ cout << Enter a string: ; gets(p1); // read a string // print the ASCII values while(*p1) cout << (int) *p1++ << ; cout << \n ; while( strcmp(s, done ) ); return 0; First Back TOC 32 Notes Prev Next Last

33 Problems with Pointers Chapter 11: Pointers Christian Jacob Here is the corrected version, so that pointer p1 is reset to the beginning of the character array s at the beginning of each loop iteration: int main() { char s[80], *p1; do{ p1 = s; cout << Enter a string: ; gets(p1); // read a string // print the ASCII values while(*p1) cout << (int) *p1++ << ; cout << \n ; while( strcmp(s, done ) ); return 0; First Back TOC 33 Notes Prev Next Last

34 Multiple Indirection Pointers to Pointers Chapter 11: Pointers Christian Jacob 6 Multiple Indirection Pointers to Pointers A pointer to a pointer a chain of pointers is a form of multiple indirection. In the case of a normal pointer the value of the pointer is the address of a value. In the case of a pointer to a pointer the first pointer contains the address of the second, normal pointer. Single Indirection Pointer address Variable value Pointer Pointer Variable Multiple Indirection address address value First Back TOC 34 Notes Prev Next Last

35 Multiple Indirection Pointers to Pointers Chapter 11: Pointers Christian Jacob Example using multiple indirection: int main() { int x, *p, **q; x = 10; p = &x; q = &p; cout << **q; // prints the value of x return 0; First Back TOC 35 Notes Prev Next Last

Module 4 Arrays, Strings, and Pointers

Module 4 Arrays, Strings, and Pointers Table of Contents CRITICAL SKILL 4.1: Use one-dimensional arrays... 2 CRITICAL SKILL 4.2: Two-Dimensional Arrays... 6 CRITICAL SKILL 4.3: Multidimensional Arrays...