1 Lecture 8 Pointers and Strings: Part 2 Section 5.4, 5.7-5.10, 5.12.1

1

Lecture 8

Pointers and Strings: Part 2Section 5.4, 5.7-5.10, 5.12.1

2

5.4Calling 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 More than one value “returned”

3

5.4Calling 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 * operator used as alias/nickname for variable

inside of function

4

fig05_06.cpp(1 of 2)

1 // Fig. 5.6: fig05_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

5


fig05_06.cppoutput (1 of 1)

19 cout << "\nThe new value of number is " << number << endl;20 21 return 0; // indicates successful termination22 23 } // end main24 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 5The new value of number is 125

6


1 // Fig. 5.7: fig05_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 );

7



19 20 cout << "\nThe new value of number is " << number << endl;21 22 return 0; // indicates successful termination23 24 } // end main25 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 5The new value of number is 125

8

5.7Pointer Expressions and Pointer Arithmetic

Pointer arithmetic Increment/decrement pointer (++ or --) Add/subtract an integer to/from a pointer( + or += , - or -=) Pointers may be subtracted from each other Pointer arithmetic meaningless unless performed on pointer to

array 5 element int array on a machine using 4 byte ints

vPtr points to first element v[ 0 ], which is at location 3000vPtr = 3000

vPtr += 2; sets vPtr to 3008vPtr points to v[ 2 ]

pointer variable vPtr

v[0] v[1] v[2] v[4]v[3]

3000 3004 3008 3012 3016location

9

5.7Pointer Expressions and Pointer Arithmetic Subtracting pointers

Returns number of elements between two addressesvPtr2 = v[ 2 ];vPtr = v[ 0 ];vPtr2 - vPtr == 2

Pointer assignment Pointer can be assigned to another pointer if both of same type If not same type, cast operator must be used Exception: pointer to void (type void *)

Generic pointer, represents any type No casting needed to convert pointer to void pointer void pointers cannot be dereferenced

10

5.7Pointer Expressions and Pointer Arithmetic Pointer comparison

Use equality and relational operators Comparisons meaningless unless pointers point to

members of same array Compare addresses stored in pointers Example: could show that one pointer points to

higher numbered element of array than other pointer

Common use to determine whether pointer is 0 (does not point to anything)

11

5.8Relationship Between Pointers and Arrays Arrays and pointers closely related

Array name like constant pointer Pointers can do array subscripting operations

Accessing array elements with pointers Element b[ n ] can be accessed by *( bPtr + n )

Called pointer/offset notation Addresses

&b[ 3 ] same as bPtr + 3 Array name can be treated as pointer

b[ 3 ] same as *( b + 3 ) Pointers can be subscripted (pointer/subscript notation)

bPtr[ 3 ] same as b[ 3 ]

12


1 // Fig. 5.20: fig05_20.cpp2 // Using subscripting and pointer notations with arrays.3 4 #include <iostream>5 6 using std::cout;7 using std::endl;8 9 int main()10 {11 int b[] = { 10, 20, 30, 40 };12 int *bPtr = b; // set bPtr to point to array b13 14 // output array b using array subscript notation15 cout << "Array b printed with:\n" 16 << "Array subscript notation\n";17 18 for ( int i = 0; i < 4; i++ )19 cout << "b[" << i << "] = " << b[ i ] << '\n';

13


21 // output array b using the array name and 22 // pointer/offset notation23 cout << "\nPointer/offset notation where "24 << "the pointer is the array name\n";25 26 for ( int offset1 = 0; offset1 < 4; offset1++ )27 cout << "*(b + " << offset1 << ") = " 28 << *( b + offset1 ) << '\n';29 30 // output array b using bPtr and array subscript notation31 cout << "\nPointer subscript notation\n";32 33 for ( int j = 0; j < 4; j++ )34 cout << "bPtr[" << j << "] = " << bPtr[ j ] << '\n';35 36 cout << "\nPointer/offset notation\n";37

14


38 // output array b using bPtr and pointer/offset notation39 for ( int offset2 = 0; offset2 < 4; offset2++ )40 cout << "*(bPtr + " << offset2 << ") = "41 << *( bPtr + offset2 ) << '\n';42 43 return 0; // indicates successful termination44 45 } // end main

Array b printed with: Array subscript notationb[0] = 10b[1] = 20b[2] = 30b[3] = 40


15

Pointer/offset notation where the pointer is the array name*(b + 0) = 10*(b + 1) = 20*(b + 2) = 30*(b + 3) = 40

Pointer subscript notationbPtr[0] = 10bPtr[1] = 20bPtr[2] = 30bPtr[3] = 40 Pointer/offset notation*(bPtr + 0) = 10*(bPtr + 1) = 20*(bPtr + 2) = 30*(bPtr + 3) = 40


16


1 // Fig. 5.21: fig05_21.cpp2 // Copying a string using array notation3 // and pointer notation.4 #include <iostream>5 6 using std::cout;7 using std::endl;8 9 void copy1( char *, const char * ); // prototype10 void copy2( char *, const char * ); // prototype11 12 int main()13 {14 char string1[ 10 ];15 char *string2 = "Hello";16 char string3[ 10 ];17 char string4[] = "Good Bye";18

17


19 copy1( string1, string2 );20 cout << "string1 = " << string1 << endl;21 22 copy2( string3, string4 );23 cout << "string3 = " << string3 << endl;24 25 return 0; // indicates successful termination26 27 } // end main28 29 // copy s2 to s1 using array notation30 void copy1( char *s1, const char *s2 )31 {32 for ( int i = 0; ( s1[ i ] = s2[ i ] ) != '\0'; i++ )33 ; // do nothing in body 34 35 } // end function copy1

18



37 // copy s2 to s1 using pointer notation38 void copy2( char *s1, const char *s2 )39 {40 for ( ; ( *s1 = *s2 ) != '\0'; s1++, s2++ )41 ; // do nothing in body 42 43 } // end function copy2

string1 = Hellostring3 = Good Bye

19

5.9Arrays of Pointers

Arrays can contain pointers Commonly used to store array of strings

char *suit[ 4 ] = {"Hearts", "Diamonds", "Clubs", "Spades" };

Each element of suit points to char * (a string) Array does not store strings, only pointers to strings

suit array has fixed size, but strings can be of any size

suit[3]

suit[2]

suit[1]

suit[0] ’H’ ’e’ ’a’ ’r’ ’t’ ’s’ ’\0’

’D’ ’i’ ’a’ ’m’ ’o’ ’n’ ’d’ ’s’ ’\0’

’C’ ’l’ ’u’ ’b’ ’s’ ’\0’

’S’ ’p’ ’a’ ’d’ ’e’ ’s’ ’\0’

20

5.10 Case Study: Card Shuffling and Dealing Simulation Card shuffling program

Use an array of pointers to strings, to store suit names Use a double scripted array (suit by value)

Place 1-52 into the array to specify the order in which the cards are dealt

deck[2][12] represents the King of Clubs

HeartsDiamondsClubsSpades

0123

Ace Two ThreeFour Five Six SevenEightNine Ten Jack QueenKing0 1 2 3 4 5 6 7 8 9 10 11 12

Clubs King

21

5.10 Case Study: Card Shuffling and Dealing Simulation Pseudocode for shuffling and dealing

simulation

For each of the 52 cards

Place card number in randomly selected unoccupied slot of deck

For each of the 52 cards

Find card number in deck array and print face and suit of card

Choose slot of deck randomly

While chosen slot of deck has been previously chosen

Choose slot of deck randomlyPlace card number in chosen slot of deck

For each slot of the deck array

If slot contains card number Print the face and suit of the card

Second refinement

Third refinement

First refinement

Initialize the suit arrayInitialize the face arrayInitialize the deck array

Shuffle the deck

Deal 52 cards

22


1 // Fig. 5.24: fig05_24.cpp2 // Card shuffling dealing program.3 #include <iostream>4 5 using std::cout;6 using std::left;7 using std::right;8 9 #include <iomanip>10 11 using std::setw;12 13 #include <cstdlib> // prototypes for rand and srand14 #include <ctime> // prototype for time15 16 // prototypes17 void shuffle( int [][ 13 ] );18 void deal( const int [][ 13 ], const char *[], const char *[] );19

23


20 int main() {21 // initialize suit array 22 const char *suit[ 4 ] = 23 { "Hearts", "Diamonds", "Clubs", "Spades" };24 25 // initialize face array 26 const char *face[ 13 ] = { "Ace", "Deuce", "Three", "Four", "Five", 27 "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King" };28 29 // initialize deck array30 int deck[ 4 ][ 13 ] = { 0 };31 32 srand( time( 0 ) ); // seed random number generator33 34 shuffle( deck );35 deal( deck, face, suit ); 36 return 0; // indicates successful termination37 } // end main38

24


39 // shuffle cards in deck40 void shuffle( int wDeck[][ 13 ] ) {41 int row;42 int column;43 44 // for each of the 52 cards, choose slot of deck randomly45 for ( int card = 1; card <= 52; card++ ) { 46 // choose new random location until unoccupied slot found47 do { 48 row = rand() % 4; 49 column = rand() % 13; 50 } while ( wDeck[ row ][ column ] != 0 ); // end do/while 51 // place card number in chosen slot of deck52 wDeck[ row ][ column ] = card;53 54 } // end for55 56 } // end function shuffle57

25


58 // deal cards in deck59 void deal( const int wDeck[][ 13 ], const char *wFace[],60 const char *wSuit[] ) {61 // for each of the 52 cards62 for ( int card = 1; card <= 52; card++ ) 63 // loop through rows of wDeck64 for ( int row = 0; row <= 3; row++ )65 66 // loop through columns of wDeck for current row67 for ( int column = 0; column <= 12; column++ )68 69 // if slot contains current card, display card70 if ( wDeck[ row ][ column ] == card ) {71 cout << setw( 5 ) << right << wFace[ column ]72 << " of " << setw( 8 ) << left 73 << wSuit[ row ] 74 << ( card % 2 == 0 ? '\n' : '\t' ); 75 } // end if76 } // end function deal

26

Nine of Spades Seven of Clubs Five of Spades Eight of ClubsQueen of Diamonds Three of Hearts Jack of Spades Five of Diamonds Jack of Diamonds Three of DiamondsThree of Clubs Six of Clubs Ten of Clubs Nine of Diamonds Ace of Hearts Queen of HeartsSeven of Spades Deuce of Spades Six of Hearts Deuce of Clubs Ace of Clubs Deuce of Diamonds Nine of Hearts Seven of Diamonds Six of Spades Eight of Diamonds Ten of Spades King of Hearts Four of Clubs Ace of Spades Ten of Hearts Four of SpadesEight of Hearts Eight of Spades Jack of Hearts Ten of Diamonds Four of Diamonds King of DiamondsSeven of Hearts King of SpadesQueen of Spades Four of Hearts Nine of Clubs Six of DiamondsDeuce of Hearts Jack of Clubs King of Clubs Three of SpadesQueen of Clubs Five of Clubs Five of Hearts Ace of Diamonds


27

5.12.1 Fundamentals of Characters and Strings Character constant

Integer value represented as character in single quotes 'z' is integer value of z

122 in ASCII String

Series of characters treated as single unit Can include letters, digits, special characters +, -, * ... String literal (string constants)

Enclosed in double quotes, for example:"I like C++"

Array of characters, ends with null character '\0' String is constant pointer

Pointer to string’s first character Like arrays

28

5.12.1 Fundamentals of Characters and Strings

String assignment Character array

char color[] = "blue"; Creates 5 element char array color

last element is '\0' Variable of type char *

char *colorPtr = "blue"; Creates pointer colorPtr to letter b in string “blue”

“blue” somewhere in memory Alternative for character array

char color[] = { ‘b’, ‘l’, ‘u’, ‘e’, ‘\0’ };

29

5.12.1 Fundamentals of Characters and Strings Reading strings

Assign input to character array word[ 20 ]cin >> word

Reads characters until whitespace or EOF String could exceed array size

cin >> setw( 20 ) >> word; Reads 19 characters (space reserved for '\0')

30

5.12.1 Fundamentals of Characters and Strings cin.getline

Read line of text cin.getline( array, size, delimiter ); Copies input into specified array until either

One less than size is reached delimiter character is input

Examplechar sentence[ 80 ];cin.getline( sentence, 80, '\n' );orstring sent;getline(cin, sent, ‘\n’);

Documents

1 Lecture 8 Pointers and Strings: Part 2 Section 5.4, 5.7-5.10, 5.12.1