2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer...
-
Upload
margaretmargaret-phillips -
Category
Documents
-
view
220 -
download
0
Transcript of 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer...
![Page 1: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/1.jpg)
2003 Prentice Hall, Inc. All rights reserved.
1
Pointers and Strings
OutlineIntroductionPointer Variable Declarations and InitializationPointer OperatorsCalling Functions by ReferenceUsing const with PointersSelection Sort Using Pass-by-Reference
![Page 2: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/2.jpg)
2003 Prentice Hall, Inc. All rights reserved.
2
Introduction
• Pointers – Powerful, but difficult to master– Enable pass-by-reference and allow the creation
of dynamic data structure (e.g., linked lists, queues, etc.)
– Close relationship with arrays and strings
![Page 3: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/3.jpg)
2003 Prentice Hall, Inc. All rights reserved.
3
Pointer Variable Declarations and Initialization
• Pointer variables– Contain memory addresses as values – Normally, variable contains specific value (direct
reference)– Pointers contain address of a variable that itself has
specific value (indirect reference)
• Indirection– Referencing value through pointer
• Pointer declarations– * indicates variable is pointer
int *myPtr;
declares pointer to int, pointer of type int *– Multiple pointers require multiple asterisks
int *myPtr1, *myPtr2;
count
7
countPtr
count
7
![Page 4: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/4.jpg)
2003 Prentice Hall, Inc. All rights reserved.
4
Pointer Variable Declarations and Initialization
• Can declare pointers to any data type• Pointer initialization
– Initialized to 0, NULL, or address• 0 or NULL points to nothing (null pointer)• NULL defined in <iostream>
![Page 5: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/5.jpg)
2003 Prentice Hall, Inc. All rights reserved.
5
Pointer Operators
• & (address operator)– Returns memory address of its operand– Example
int y = 5;int *yPtr;yPtr = &y; // yPtr gets address of y
– yPtr “points to” y
yPtr
y5
yptr
500000 600000
y
600000 5
address of y is value of yptr
![Page 6: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/6.jpg)
2003 Prentice Hall, Inc. All rights reserved.
6
Pointer Operators
• * (indirection or dereferencing operator)– Returns synonym for the object its pointer operand
points to.– *yPtr returns y (because yPtr points to y )
• Example: cout << *yPtr << endl;
returns the value of y cout << y << endl;
– dereferenced pointer is lvalue *yPtr = 9; // assigns 9 to y
cin >> *yPtr; // receive a value from input * and & are inverses of each other
![Page 7: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/7.jpg)
2003 Prentice Hall, Inc.All rights reserved.
Outline7
1 // Fig. 8.4: fig08_04.cpp2 // Using the & and * operators.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 int main()9 {10 int a; // a is an integer11 int *aPtr; // aPtr is a pointer to an integer12 13 a = 7;14 aPtr = &a; // aPtr assigned address of a15 16 cout << "The address of a is " << &a17 << "\nThe value of aPtr is " << aPtr;18 19 cout << "\n\nThe value of a is " << a20 << "\nThe value of *aPtr is " << *aPtr;21 22 cout << "\n\nShowing that * and & are inverses of "23 << "each other.\n&*aPtr = " << &*aPtr24 << "\n*&aPtr = " << *&aPtr << endl;25
* and & are inverses of each other
![Page 8: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/8.jpg)
2003 Prentice Hall, Inc.All rights reserved.
Outline8
26 return 0; // indicates successful termination27 28 } // end main
The address of a is 0012FED4
The value of aPtr is 0012FED4
The value of a is 7
The value of *aPtr is 7
Showing that * and & are inverses of each other.
&*aPtr = 0012FED4
*&aPtr = 0012FED4 * and & are inverses; same result when both applied to aPtr
![Page 9: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/9.jpg)
2003 Prentice Hall, Inc. All rights reserved.
9
Calling Functions by Reference
• 3 ways to pass arguments to function– Pass-by-value– Pass-by-reference with reference arguments– Pass-by-reference with pointer arguments
• return can return one value from function
• Arguments passed to function using reference arguments– Modify original values of arguments
• Eliminate the overhead of passing large objects!
– More than one value “returned”
![Page 10: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/10.jpg)
2003 Prentice Hall, Inc. All rights reserved.
10
Calling Functions by Reference
• Pass-by-reference with pointer arguments– Simulate pass-by-reference
• Use pointers and (*) indirection operator
– Pass address of argument using & operator– Arrays not passed with & because array name
already pointer (pointer to the first element in the array, &arrayName[0])
– * operator is used in the function as alias/nickname for variable
• A function receiving an address as an argument must define a pointer parameter to receive the address
![Page 11: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/11.jpg)
2003 Prentice Hall, Inc.All rights reserved.
Outline11
1 // Fig. 8.6: fig08_06.cpp2 // Cube a variable using pass-by-value.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 int cubeByValue( int ); // prototype9 10 int main()11 {12 int number = 5;13 14 cout << "The original value of number is " << number;15 16 // pass number by value to cubeByValue17 number = cubeByValue( number );18 19 cout << "\nThe new value of number is " << number << endl;20 21 return 0; // indicates successful termination22 23 } // end main24
Pass number by value; result returned by cubeByValue
![Page 12: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/12.jpg)
2003 Prentice Hall, Inc.All rights reserved.
Outline12
25 // calculate and return cube of integer argument 26 int cubeByValue( int n ) 27 { 28 return n * n * n; // cube local variable n and return result29 30 } // end function cubeByValue
The original value of number is 5
The new value of number is 125
cubeByValue receives parameter passed-by-value
Cubes and returns local variable n
![Page 13: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/13.jpg)
2003 Prentice Hall, Inc.All rights reserved.
Outline13
1 // Fig. 8.7: fig08_07.cpp2 // Cube a variable using pass-by-reference 3 // with a pointer argument.4 #include <iostream>5 6 using std::cout;7 using std::endl;8 9 void cubeByReference( int * ); // prototype10 11 int main()12 {13 int number = 5;14 15 cout << "The original value of number is " << number;16 17 // pass address of number to cubeByReference18 cubeByReference( &number );19 20 cout << "\nThe new value of number is " << number << endl;21 22 return 0; // indicates successful termination23 24 } // end main25
Apply address operator & to pass address of number to cubeByReference
cubeByReference modified variable number
Prototype indicates parameter is pointer to int
![Page 14: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/14.jpg)
2003 Prentice Hall, Inc.All rights reserved.
Outline14
26 // calculate cube of *nPtr; modifies variable number in main27 void cubeByReference( int *nPtr ) 28 { 29 *nPtr = *nPtr * *nPtr * *nPtr; // cube *nPtr 30 31 } // end function cubeByReference
The original value of number is 5
The new value of number is 125
cubeByReference receives address of int variable,i.e., pointer to an int
Modify and access int variable using indirection operator *
![Page 15: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/15.jpg)
2003 Prentice Hall, Inc. All rights reserved.
15
Using const with Pointers
• const qualifier– Value of variable should not be modified– const used when function does not need to
change a variable
• Principle of least privilege– Award a function enough access to accomplish its
task, but no more
• Four ways to pass pointer to function– Non-constant pointer to non-constant data
• Highest amount of access is granted– Non-constant pointer to constant data– Constant pointer to non-constant data– Constant pointer to constant data
• Least amount of access is granted
![Page 16: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/16.jpg)
2003 Prentice Hall, Inc.All rights reserved.
Outline16
1 // Fig. 8.10: fig08_10.cpp2 // Converting lowercase letters to uppercase letters3 // using a non-constant pointer to non-constant data.4 #include <iostream>5 6 using std::cout;7 using std::endl;8 9 #include <cctype> // prototypes for islower and toupper10 11 void convertToUppercase( char * );12 13 int main()14 {15 char phrase[] = "characters and $32.98";16 17 cout << "The phrase before conversion is: " << phrase;18 convertToUppercase( phrase );19 cout << "\nThe phrase after conversion is: " 20 << phrase << endl;21 22 return 0; // indicates successful termination23 24 } // end main25
Parameter is non-constant pointer to non-constant data
convertToUppercase modifies variable phrase
![Page 17: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/17.jpg)
2003 Prentice Hall, Inc.All rights reserved.
Outline17
26 // convert string to uppercase letters 27 void convertToUppercase( char *sPtr ) 28 { 29 while ( *sPtr != '\0' ) { // current character is not '\0'30 31 if ( islower( *sPtr ) ) // if character is lowercase, 32 *sPtr = toupper( *sPtr ); // convert to uppercase 33 34 ++sPtr; // move sPtr to next character in string 35 36 } // end while 37 38 } // end function convertToUppercase
The phrase before conversion is: characters and $32.98
The phrase after conversion is: CHARACTERS AND $32.98
Parameter sPtr non-constant pointer to non-constant data
Function islower returns true if character is lowercase
Function toupper returns corresponding uppercase character if original character lowercase; otherwise toupper returns original (uppercase) character
When operator ++ applied to pointer that points to array, memory address stored in pointer modified to point to next element of array.
![Page 18: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/18.jpg)
2003 Prentice Hall, Inc.All rights reserved.
Outline18
1 // Fig. 8.11: fig08_11.cpp2 // Printing a string one character at a time using3 // a non-constant pointer to constant data.4 #include <iostream>5 6 using std::cout;7 using std::endl;8 9 void printCharacters( const char * );10 11 int main()12 {13 const char phrase[] = "print characters of a string";14 15 cout << "The string is:\n";16 printCharacters( phrase );17 cout << endl;18 19 return 0; // indicates successful termination20 21 } // end main22
Parameter is non-constant pointer to constant data.
Pass pointer phrase to function printCharacters.
a non-constant pointer to constant data is a pointer that can be modified to point to any data item of the appropriate type, but the data to which it points cannot be modified through that pointer
![Page 19: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/19.jpg)
2003 Prentice Hall, Inc.All rights reserved.
Outline19
23 // sPtr cannot modify the character to which it points,24 // i.e., sPtr is a "read-only" pointer25 void printCharacters( const char *sPtr )26 {27 for ( ; *sPtr != '\0'; sPtr++ ) // no initialization28 cout << *sPtr; 29 30 } // end function printCharacters
The string is:
print characters of a string
sPtr is non-constant pointer to constant data; cannot modify character to which sPtr points.Increment sPtr to point to next character.
![Page 20: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/20.jpg)
2003 Prentice Hall, Inc.All rights reserved.
Outline20
1 // Fig. 8.12: fig08_12.cpp2 // Attempting to modify data through a3 // non-constant pointer to constant data.4 5 void f( const int * ); // prototype6 7 int main()8 {9 int y;10 11 f( &y ); // f attempts illegal modification12 13 return 0; // indicates successful termination14 15 } // end main16 17 // xPtr cannot modify the value of the variable 18 // to which it points 19 void f( const int *xPtr )20 {21 *xPtr = 100; // error: cannot modify a const object22 23 } // end function f
d:\cpphtp8_examples\ch08\Fig08_12.cpp(21) : error C2166: l-value specifies const object
Parameter is non-constant pointer to constant data.
Pass address of int variable y to attempt illegal modification.
Attempt to modify const object pointed to by xPtr.
Error produced when attempting to compile.
![Page 21: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/21.jpg)
2003 Prentice Hall, Inc. All rights reserved.
21
Using const with Pointers
• const pointers– Always point to same memory location– Default for array name– Must be initialized when declared
![Page 22: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/22.jpg)
2003 Prentice Hall, Inc.All rights reserved.
Outline22
1 // Fig. 8.13: fig08_13.cpp2 // Attempting to modify a constant pointer to3 // non-constant data.4 5 int main()6 {7 int x, y;8 9 // ptr is a constant pointer to an integer that can 10 // be modified through ptr, but ptr always points to the11 // same memory location. 12 int * const ptr = &x; 13 14 *ptr = 7; // allowed: *ptr is not const15 ptr = &y; // error: ptr is const; cannot assign new address16 17 return 0; // indicates successful termination18 19 } // end main
d:\cpphtp8_examples\ch08\Fig08_13.cpp(15) : error C2166: l-value specifies const object
ptr is constant pointer to integer.Can modify x (pointed to by
ptr) since x not constant.Cannot modify ptr to point to new address since ptr is constant.
Line 15 generates compiler error by attempting to assign new address to constant pointer.
a constant pointer to non-constant data is a pointer that always points to the same memory location. Data at that location can be changed through the pointer. (e.g., array name)
![Page 23: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/23.jpg)
2003 Prentice Hall, Inc.All rights reserved.
Outline23
1 // Fig. 8.14: fig08_14.cpp2 // Attempting to modify a constant pointer to constant data.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 int main()9 {10 int x = 5, y;11 12 // ptr is a constant pointer to a constant integer. 13 // ptr always points to the same location; the integer14 // at that location cannot be modified.15 const int * const ptr = &x; 16 17 cout << *ptr << endl;18 19 *ptr = 7; // error: *ptr is const; cannot assign new value 20 ptr = &y; // error: ptr is const; cannot assign new address21 22 return 0; // indicates successful termination23 24 } // end main
ptr is constant pointer to integer constant.
Cannot modify x (pointed to by ptr) since *ptr declared constant.Cannot modify ptr to point to new address since ptr is constant.
a constant pointer to a constant data is a pointer that always points to the same memory location and data at that location cannot be modified.
![Page 24: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/24.jpg)
2003 Prentice Hall, Inc.All rights reserved.
Outline24
d:\cpphtp8_examples\ch08\Fig08_14.cpp(19) : error C2166: l-value specifies const object
d:\cpphtp8_examples\ch08\Fig08_14.cpp(20) : error C2166: l-value specifies const object
Line 19 generates compiler error by attempting to modify constant object.Line 20 generates compiler
error by attempting to assign new address to constant pointer.
![Page 25: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/25.jpg)
2003 Prentice Hall, Inc. All rights reserved.
25
Selection Sort Using Pass-by-Reference
• Implement selectionSort using pointers– Want function swap to access array elements
• Individual array elements: scalars– Passed by value “by default”
• Pass by reference using address operator &
– Selection sort:• First iteration: select smallest element in array
and swap it with first element of array• Second iteration: select second smallest and swap
it with second element in array• Etc…..
![Page 26: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/26.jpg)
2003 Prentice Hall, Inc.All rights reserved.
Outline26
1 // Fig. 8.15: fig08_15.cpp2 // This program puts values into an array, sorts the values into3 // ascending order, and prints the resulting array.4 #include <iostream>5 6 using std::cout;7 using std::endl;8 9 #include <iomanip>10 11 using std::setw;12 13 void selectionSort( int *, const int ); // prototype14 void swap( int * const, int * const ); // prototype15 16 int main()17 {18 const int arraySize = 10;19 int a[ arraySize ] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 };20 21 cout << "Data items in original order\n";22 23 for ( int i = 0; i < arraySize; i++ )24 cout << setw( 4 ) << a[ i ];25
![Page 27: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/27.jpg)
2003 Prentice Hall, Inc.All rights reserved.
Outline27
26 selectionSort( a, arraySize ); // sort the array27 28 cout << "\nData items in ascending order\n";29 30 for ( int j = 0; j < arraySize; j++ )31 cout << setw( 4 ) << a[ j ];32 33 cout << endl;34 35 return 0; // indicates successful termination36 37 } // end main38 39 // sort an array of integers using selection sort algorithm40 void selectionSort( int *array, const int size )41 {42 int smallest;43 for ( int i = 0; i < size - 1; i++ ) // loop over size-1 elements44 {45 smallest = i;46 for ( int index = i + 1; index < size; index++ )47 if ( array[ index ] < array[ smallest ] )48 smallest = index;49 // swap adjacent elements if they are out of order50 swap( &array[ i ], &array[ smallest ] );51 } // end for52 } // end function selectionSort
Declare as int *array (rather than int array[]) to indicate function selectionSort receives single-subscripted array.
Receives size of array as argument; declared const to ensure size not modified.
![Page 28: 2003 Prentice Hall, Inc. All rights reserved. 1 Pointers and Strings Outline Introduction Pointer Variable Declarations and Initialization Pointer Operators.](https://reader036.fdocuments.in/reader036/viewer/2022062423/5697c0211a28abf838cd2cdb/html5/thumbnails/28.jpg)
2003 Prentice Hall, Inc.All rights reserved.
Outline28
53 54 // swap values at memory locations to which 55 // element1Ptr and element2Ptr point 56 void swap( int * const element1Ptr, int * const element2Ptr )57 { 58 int hold = *element1Ptr; 59 *element1Ptr = *element2Ptr; 60 *element2Ptr = hold; 61 62 } // end function swap
Data items in original order
2 6 4 8 10 12 89 68 45 37
Data items in ascending order
2 4 6 8 10 12 37 45 68 89
Pass arguments by reference, allowing function to swap values at memory locations.