Cpphtp5 22 IM

22
The same old charitable lie

Repeated as the years scoot
by
Perpetually makes a hit
You really havent changed
a bit!
Margaret Fishback
The chief defect of Henry

King
Was chewing little bits of
string.
Bits,
Characters,
C-Strings and
structs
OBJECTIVES
In this chapter you will learn:
To create and use structs.
To pass structs to functions by value and by reference.
Hilaire Belloc
Vigorous writing is concise.

A sentence should contain no
unnecessary words, a
paragraph no unnecessary
sentences.
William Strunk, Jr.
To use typedef to create aliases for previously dened

data types and structs.
To manipulate data with the bitwise operators and to
create bit elds for storing data compactly.
To use the functions of the character- handling library
<cctype>.
To use the string-conversion functions of the generalutilities library <cstdlib>.
To use the string-processing functions of the stringhandling library <cstring>.
2006 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.
Chapter 22 Bits, Characters, C-Strings and structs
Self-Review Exercises
22.1
Fill in the blanks in each of the following:

a) A(n)
is a collection of related variables under one name.
ANS: structure.
b) The bits in the result of an expression using the
operator are set to one if
the corresponding bits in each operand are set to one. Otherwise, the bits are set to zero.
ANS: bitwise AND (&).
.
c) The variables declared in a structure definition are called its
ANS: members.
d) The bits in the result of an expression using the
operator are set to one if
at least one of the corresponding bits in either operand is set to one. Otherwise, the bits
are set to zero.
ANS: bitwise inclusive-OR (|).
e) Keyword
introduces a structure declaration.
ANS: struct.
f) Keyword
is used to create a synonym for a previously defined data type.
ANS: typedef.
g) Each bit in the result of an expression using the
operator is set to one if
exactly one of the corresponding bits in either operand is set to one. Otherwise, the bit
is set to zero.
ANS: bitwise exclusive-OR (^).
h) The bitwise AND operator & is often used to
bits (i.e., to select certain bits
from a bit string while zeroing others).
ANS: mask.
i) A structure member is accessed with either operator
or
.
ANS: structure member (.), structure pointer (->).
j) The
and
operators are used to shift the bits of a value to the
left or to the right, respectively.
ANS: left-shift operator (<<), right-shift operator (>>).
22.2
State whether each of the following is true or false. If false, explain why.
a) Structures may contain only one data type.
ANS: False. A structure can contain many data types.
b) Members of different structures must have unique names.
ANS: False. The members of separate structures can have the same names, but the members
of the same structure must have unique names.
c) Keyword typedef is used to define new data types.
ANS: False. typedef is used to define aliases for previously defined data types.
d) Structures are always passed to functions by reference.
ANS: False. Structures are passed to functions by value by default and may be passed by
reference.
22.3
Write a single statement or a set of statements to accomplish each of the following:

a) Define a structure called Part containing int variable partNumber and char array partName, whose values may be as long as 25 characters.
ANS: struct Part
{
int partNumber;
char partName[ 26 ];
};
Self-Review Exercises
b) Define PartPtr to be a synonym for the type Part *.

ANS: typedef Part * PartPtr;
c) Use separate statements to declare variable a to be of type Part, array b[

type Part and variable ptr to be of type pointer to Part.
10 ]
to be of
ANS: Part a;
Part b[ 10 ];
Part *ptr;
d) Read a part number and a part name from the keyboard into the members of variable a.
ANS: cin >> a.partNumber >> a.partName;
e) Assign the member values of variable a to element three of array b.

ANS: b[ 3 ] = a;
f) Assign the address of array b to the pointer variable ptr.

ANS: ptr = b;
g) Print the member values of element three of array b, using the variable ptr and the structure pointer operator to refer to the members.
ANS: cout << ( ptr + 3 )->partNumber << ' '
<< ( ptr + 3 )->partName << endl;
22.4
Find the error in each of the following:

a) Assume that struct Card has been defined as containing two pointers to type char
namely, face and suit. Also, the variable c has been declared to be of type Card, and
the variable cPtr has been declared to be of type pointer to Card. Variable cPtr has been
assigned the address of c.
cout << *cPtr.face << endl;
ANS: Error: The parentheses that should enclose *cPtr have been omitted, causing the or-
der of evaluation of the expression to be incorrect.

b) Assume that struct Card has been defined as containing two pointers to type char
namely, face and suit. Also, the array hearts[ 13 ] has been declared to be of type
Card. The following statement should print the member face of element 10 of the array.
cout << hearts.face << endl;
ANS: Error: The array subscript has been omitted. The expression should be
c)
hearts[ 10 ].face.
struct Person
{
char lastName[ 15 ];
char firstName[ 15 ];
int age;
}
ANS: Error: A semicolon is required to end a structure definition.

d) Assume that variable p has been declared as type Person and that variable
declared as type Card.
has been
p = c;
ANS: Error: Variables of different structure types cannot be assigned to one another.
22.5 Write a single statement to accomplish each of the following. Assume that variables c
(which stores a character), x, y and z are of type int; variables d, e and f are of type double; variable
ptr is of type char * and arrays s1[ 100 ] and s2[ 100 ] are of type char.

a) Convert the character stored in variable
variable c.
to an uppercase letter. Assign the result to
ANS: c = toupper( c );
b) Determine if the value of variable c is a digit. Use the conditional operator as shown in
Figs. 22.1822.20 to print " is a " or " is not a " when the result is displayed.
ANS: cout << '\'' << c << "\' "
<< ( isdigit( c ) ? "is a" : "is not a" )
<< " digit" << endl;
c) Convert the string "1234567" to long, and print the value.

ANS: cout << atol( "1234567" ) << endl;
d) Determine whether the value of variable c is a control character. Use the conditional
operator to print " is a " or " is not a " when the result is displayed.
ANS: cout << '\'' << c << "\' "
<< ( iscntrl( c ) ? "is a" : "is not a" )
<< " control character" << endl;
e) Assign to ptr the location of the last occurrence of c in s1.

ANS: ptr = strrchr( s1, c );
f) Convert the string "8.63582" to double, and print the value.
ANS: out << atof( "8.63582" ) << endl;
g) Determine whether the value of c is a letter. Use the conditional operator to print " is
a " or " is not a " when the result is displayed.
ANS: cout << '\'' << c << "\' "

<< ( isalpha( c ) ? "is a" : "is not a" )
<< " letter" << endl;
h) Assign to ptr the location of the first occurrence of s2 in s1.

ANS: ptr = strstr( s1, s2 );
i) Determine whether the value of variable c is a printing character. Use the conditional
operator to print " is a " or " is not a " when the result is displayed.
ANS: cout << '\'' << c << "\' "
<< ( isprint( c ) ? "is a" : "is not a" )
<< " printing character" << endl;
j) Assign to ptr the location of the first occurrence in s1 of any character from s2.
ANS: ptr = strpbrk( s1, s2 );
k) Assign to ptr the location of the first occurrence of c in s1.

ANS: ptr = strchr( s1, c );
l) Convert the string "-21" to int, and print the value.

ANS: cout << atoi( "-21" ) << endl;
Exercises
22.6
Provide the definition for each of the following structures:

a) Structure Inventory, containing character array partName[
floating-point price, integer stock and integer reorder.
30 ],
integer partNumber,
ANS: struct Inventory

{
char partName[ 30 ];
int partNumber;
double price;
Exercises
int stock;
int reorder;
};
b) A structure called Address that contains character arrays streetAddress[

20 ], state[ 3 ] and zipCode[ 6 ].
25 ], city[
ANS: struct Address

{
char streetAddress[ 25 ];
char city[ 20 ];
char state[ 3 ];
char zipCode[ 6 ];
};
c) Structure Student, containing arrays firstName[ 15 ] and lastName[

homeAddress of type struct Address from part (b).
15 ] and variable
ANS: struct Student

{
struct Address homeAddress;
};
d) Structure Test, containing 16 bit fields with widths of 1 bit. The names of the bit fields
are the letters a to p.
ANS: struct Test
{
unsigned a:1, b:1, c:1, d:1, e:1, f:1, g:1, h:1,
i:1, j:1, k:1, l:1, m:1, n:1, o:1, p:1;
};
22.7
Consider the following structure definitions and variable declarations:

struct Customer {
int customerNumber;
struct {
char phoneNumber[ 11 ];
char address[ 50 ];
char city[ 15 ];
char state[ 3 ];
char zipCode[ 6 ];
} personal;
} customerRecord, *customerPtr;
customerPtr = &customerRecord;
Write a separate expression that accesses the structure members in each of the following parts:
a) Member lastName of structure customerRecord.
ANS: customerRecord.lastName
b) Member lastName of the structure pointed to by customerPtr.

ANS: customerPtr->lastName
c) Member firstName of structure customerRecord.

ANS: customerRecord.firstName

d) Member firstName of the structure pointed to by customerPtr.
ANS: customerPtr->firstName
e) Member customerNumber of structure customerRecord.

ANS: customerRecord.customerNumber
f) Member customerNumber of the structure pointed to by customerPtr.

ANS: customerPtr->customerNumber
g) Member phoneNumber of member personal of structure customerRecord.

ANS: customerRecord.personal.phoneNumber
h) Member phoneNumber of member personal of the structure pointed to by customerPtr.

ANS: customerPtr->personal.phoneNumber
i) Member address of member personal of structure customerRecord.

ANS: customerRecord.personal.address
j) Member address of member personal of the structure pointed to by customerPtr.

ANS: customerPtr->personal.address
k) Member city of member personal of structure customerRecord.

ANS: customerRecord.personal.city
l) Member city of member personal of the structure pointed to by customerPtr.

ANS: customerPtr->personal.city
m) Member state of member personal of structure customerRecord.

ANS: customerRecord.personal.state
n) Member state of member personal of the structure pointed to by customerPtr.

ANS: customerPtr->personal.state
o) Member zipCode of member personal of structure customerRecord.

ANS: customerRecord.personal.zipCode
p) Member zipCode of member personal of the structure pointed to by customerPtr.

ANS: customerPtr->personal.zipCode
22.8 Modify the program of Fig. 22.14 to shuffle the cards using a high-performance shuffle, as
shown in Fig. 22.3. Print the resulting deck in two-column format, as in Fig. 22.4. Precede each
card with its color.
ANS:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Exercise 22.8 Solution: DeckOfCards.h

// Definition of class DeckOfCards that
// represents a deck of playing cards.
// BitCard structure definition with bit fields
struct BitCard
{
unsigned face : 4; // 4 bits; 0-15
unsigned suit : 2; // 2 bits; 0-3
unsigned color : 1; // 1 bit; 0-1
}; // end struct BitCard
// DeckOfCards class definition
class DeckOfCards
{
public:
DeckOfCards(); // constructor initializes deck
void shuffle(); // shuffle cards in deck
void deal(); // deals cards in deck
private:
Exercises
21
22
BitCard deck[ 52 ]; // represents deck of cards

}; // end class DeckOfCards
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
// Exercise 22.8 Solution: DeckOfCards.cpp

// Member-function definitions for class DeckOfCards that simulates
// the shuffling and dealing of a deck of playing cards.
#include <iostream>
using std::cout;
using std::endl;
#include <iomanip>
using std::setw;
using std::left;
using std::right;
#include <cstdlib>
using std::rand;
#include "DeckOfCards.h" // DeckOfCards class definition
// no-argument DeckOfCards constructor intializes deck
DeckOfCards::DeckOfCards()
{
for ( int i = 0; i <= 51; i++ )
{
deck[ i ].face = i % 13; // faces in order
deck[ i ].suit = i / 13; // suits in order
deck[ i ].color = i / 26; // colors in order
} // end for
} // end no-argument DeckOfCards constructor
// shuffle cards in deck
void DeckOfCards::shuffle()
{
// shuffle cards randomly
for ( int i = 0; i < 52; i++ )
{
int j = rand() % 52;
BitCard temp = deck[ i ];
deck[ i ] = deck[ j ];
deck[ j ] = temp;
} // end for
} // end function shuffle
// deal cards in deck
void DeckOfCards::deal()
{
char *face[] = { "Ace", "Deuce", "Three", "Four", "Five", "Six",
"Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King" };
char *suit[] = { "Hearts", "Diamonds", "Clubs", "Spades" };
char *color[] = { "Red", "Black" };
for ( int i = 0; i < 52; i++ )
8
51
52
53
54
55
56
57
1
2
3
4
5
6
7
8
9
10
11
cout << right << setw( 5 ) << color[ deck[ i ].color ] << ": "
<< setw( 8 ) << face[ deck[ i ].face ] << " of "
<< left << setw( 8 ) << suit[ deck[ i ].suit ]
<< ( ( i + 1 ) % 2 ? '\t' : '\n' );
} // end for
} // end function deal
// Exercise 22.8 Solution: ex22_08.cpp

// Card shuffling and dealing program.
#include "DeckOfCards.h" // DeckOfCards class definition
int main()
{
DeckOfCards deckOfCards; // create DeckOfCards object
deckOfCards.shuffle(); // shuffle the cards in the deck
deckOfCards.deal(); // deal the cards in the deck
return 0; // indicates successful termination
} // end main
Black:
Red:
Red:
Red:
Black:
Red:
Red:
Red:
Red:
Red:
Black:
Black:
Red:
Red:
Black:
Black:
Black:
Red:
Red:
Black:
Black:
Black:
Black:
Red:
Red:
Red:
Three
Ten
Five
King
Ace
Seven
Jack
King
Queen
Deuce
Nine
Four
Four
Eight
Queen
Ace
Deuce
Three
Nine
Jack
King
Five
Seven
Queen
Six
Ace
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
Spades
Diamonds
Diamonds
Diamonds
Clubs
Diamonds
Hearts
Hearts
Hearts
Diamonds
Spades
Spades
Hearts
Hearts
Clubs
Spades
Spades
Diamonds
Diamonds
Clubs
Spades
Spades
Spades
Diamonds
Diamonds
Hearts
Red:
Red:
Red:
Black:
Red:
Red:
Black:
Black:
Black:
Black:
Black:
Black:
Black:
Black:
Red:
Red:
Black:
Black:
Red:
Black:
Red:
Black:
Red:
Red:
Black:
Black:
Nine
Ten
Eight
Five
Five
Ace
Six
Queen
Ten
Three
Six
Jack
King
Ten
Four
Seven
Eight
Deuce
Deuce
Four
Six
Nine
Three
Jack
Eight
Seven
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
of
Hearts
Hearts
Diamonds
Clubs
Hearts
Diamonds
Clubs
Spades
Clubs
Clubs
Spades
Spades
Clubs
Spades
Diamonds
Hearts
Spades
Clubs
Hearts
Clubs
Hearts
Clubs
Hearts
Diamonds
Clubs
Clubs
Exercises
22.9 Write a program that right-shifts an integer variable 4 bits. The program should print the
integer in bits before and after the shift operation. Does your system place zeros or ones in the vacated bits?
ANS:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

// Program that right-shifts an integer variable 4 bits.
#include <iostream>
using std::cout;
using std::endl;
using std::cin;
#include <iomanip>
using std::setw;
void displayBits( unsigned ); // prototype
int main()
{
unsigned val;
cout << "Enter an integer: ";
cin >> val;
cout << "Before right shifting 4 bits is:\n";
displayBits( val );
cout << "After right shifting 4 bits is:\n";
displayBits( val >> 4 );
return 0;
} // end main
// display the bits of value
void displayBits( unsigned value )
{
const int SHIFT = 8 * sizeof( unsigned ) - 1;
const unsigned MASK = 1 << SHIFT;
cout << setw( 7 ) << value << " = ";
for ( unsigned c = 1; c <= SHIFT + 1; c++ )
{
cout << ( value & MASK ? '1' : '0' );
value <<= 1;
if ( c % 8 == 0 )
cout << ' ';
} // end for
cout << endl;
} // end function displayBits
10
Enter an integer: 5345

Before right shifting 4 bits is:
5345 = 00000000 00000000 00010100 11100001
After right shifting 4 bits is:
334 = 00000000 00000000 00000001 01001110
22.10 Left-shifting an unsigned integer by 1 bit is equivalent to multiplying the value by 2. Write
function power2 that takes two integer arguments, number and pow, and calculates
number * 2pow
Use a shift operator to calculate the result. The program should print the values as integers and as bits.
ANS:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include <iostream>
using std::cout;
using std::endl;
using std::cin;
#include <iomanip>
using std::setw;
void displayBits( unsigned ); // prototype
unsigned power2( unsigned, unsigned ); // prototype
int main()
{
unsigned number;
unsigned pow;
unsigned result;
cout << "Enter two integers: ";
cin >> number >> pow;
cout << "number:\n";
displayBits( number );
cout << "\npower:\n";
displayBits( pow );
result = power2( number, pow );
cout << '\n' << number << " * 2^" << pow << " = " << result << '\n';
displayBits( result );
return 0;
} // end main
// shifting n
unsigned power2( unsigned n, unsigned p )
{
return n << p; // shift n to the left p times
} // end function power2
Exercises
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
11

{
cout << setw( 7 ) << value << " = ";
{
cout << ( value & MASK ? '1' : '0' );
value <<= 1; // shift value left by 1
if ( c % 8 == 0 ) // output a space after 8 bits
cout << ' ';
} // end for
cout << endl;
Enter two integers: 4 7

number:
4 = 00000000 00000000 00000000 00000100
power:
7 = 00000000 00000000 00000000 00000111
4 * 2^7 = 512
512 = 00000000 00000000 00000010 00000000
22.11 The left-shift operator can be used to pack two character values into a two-byte unsigned
integer variable. Write a program that inputs two characters from the keyboard and passes them to
function packCharacters. To pack two characters into an unsigned integer variable, assign the first
character to the unsigned variable, shift the unsigned variable left by 8 bit positions and combine
the unsigned variable with the second character using the bitwise inclusive-OR operator. The program should output the characters in their bit format before and after they are packed into the unsigned integer to prove that they are in fact packed correctly in the unsigned variable.
ANS:
1
2
3
4
5
6
7
8
9
10
11
12
13

#include <iostream>
using std::cout;
using std::endl;
using std::cin;
#include <iomanip>
using std::setw;
unsigned packCharacters( char, char );
void displayBits( unsigned );
int main()
12
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
char a;
char b;
unsigned result;
cout << "Enter two characters: ";
cin >> a >> b;
cout << "\n\'" << a << '\'' << " in bits as an unsigned integer is:\n";
displayBits( a );
cout << '\'' << b << '\'' << " in bits as an unsigned integer is:\n";
displayBits( b );
result = packCharacters( a, b );
cout << "\n\'" << a << '\'' << " and " << '\'' << b << '\''
<< " packed in an unsigned integer:\n";
displayBits( result );
return 0;
} // end main
// pack two character value into unsigned integer
unsigned packCharacters( char x, char y )
{
unsigned pack = x;
pack <<= 8; // left shift assignment operator
pack |= y; // bitwise exclusive-OR operator
return pack;
} // end function packCharacters
// display the bits in value
{
cout << setw( 7 ) << value << " = ";
{
cout << ( value & MASK ? '1' : '0' );
value <<= 1;
if ( c % 8 == 0 ) // output a space after 8 bits
cout << ' ';
} // end for
cout << endl;
Exercises
13
Enter two characters: J K

'J' in bits as an unsigned integer is:
74 = 00000000 00000000 00000000 01001010
'K' in bits as an unsigned integer is:
75 = 00000000 00000000 00000000 01001011
'J' and 'K' packed in an unsigned integer:
19019 = 00000000 00000000 01001010 01001011
22.12 Using the right-shift operator, the bitwise AND operator and a mask, write function unpackCharacters that takes the unsigned integer from Exercise 22.11 and unpacks it into two characters. To unpack two characters from an unsigned two-byte integer, combine the unsigned integer
with the mask 65280 (11111111 00000000) and right-shift the result 8 bits. Assign the resulting value
to a char variable. Then, combine the unsigned integer with the mask 255 (00000000 11111111).
Assign the result to another char variable. The program should print the unsigned integer in bits
before it is unpacked, then print the characters in bits to confirm that they were unpacked correctly.
ANS:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <iostream>
using std::cout;
using std::endl;
#include <iomanip>
using std::setw;
// prototypes
void unpackCharacters( char * const, char * const, unsigned );
int main()
{
char a;
char b;
unsigned packed = 16706;
cout << "The packed character representation is:\n";
displayBits( packed );
// demonstrate unpacking of characters
unpackCharacters( &a, &b, packed );
cout << "\nThe unpacked characters are \'" << a << "\' and \'" << b
<< "\'\n";
displayBits( a );
displayBits( b );
return 0;
} // end main
// take apart the characters
void unpackCharacters( char * const aPtr, char * const bPtr,
14
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
unsigned pack )
unsigned mask1 = 65280;
unsigned mask2 = 255;
*aPtr = static_cast< char >( ( pack & mask1 ) >> 8 );

*bPtr = static_cast< char >( pack & mask2 );
} // end function unpackCharacters
{
cout << setw( 7 ) << value << " = ";
{
cout << ( value & MASK ? '1' : '0' );
value <<= 1;
if ( c % 8 == 0 )
cout << ' ';
} // end for
cout << endl;
The packed character representation is:

16706 = 00000000 00000000 01000001 01000010
The unpacked characters are 'A' and 'B'
65 = 00000000 00000000 00000000 01000001
66 = 00000000 00000000 00000000 01000010
22.13 If your system uses four-byte integers, rewrite the program of Exercise 22.11 to pack four
characters.
22.14 If your system uses four-byte integers, rewrite the function unpackCharacters of
Exercise 22.12 to unpack four characters. Create the masks you need to unpack the 4 characters by
left-shifting the value 255 in the mask variable by 8 bits 0, 1, 2 or 3 times (depending on the byte
you are unpacking).
22.15 Write a program that reverses the order of the bits in an unsigned integer value. The program should input the value from the user and call function reverseBits to print the bits in reverse
order. Print the value in bits both before and after the bits are reversed to confirm that the bits are
reversed properly.
ANS:
1
2
3

#include <iostream>
using std::cout;
Exercises
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
using std::endl;
using std::cin;
#include <iomanip>
using std::setw;
// prototypes
void reverseBits( unsigned * const );
int main()
{
unsigned a;
cout << "Enter an unsigned integer: ";
cin >> a;
// before call to reverseBits
cout << "\nBefore bits are reversed:\n";
displayBits( a );
// after call to reverseBits
reverseBits( &a );
cout << "\nAfter bits are reversed:\n";
displayBits( a );
return 0;
} // end main
// reverse the bits
void reverseBits( unsigned * const vPtr )
{
const unsigned MASK = 1;
unsignedvalue = *vPtr;
for ( int i = 0; i <= 15; i++ )
{
*vPtr <<= 1; // left shift the pointer
*vPtr |= ( value & MASK ); // inclusive-OR operator
value >>= 1; // right shift
} // end for
} // end function reverseBits
// display the bits
{
cout << setw( 7 ) << value << " = ";
{
15
16
58
59
60
61
62
63
64
65
66
cout << ( value & MASK ? '1' : '0' );

value <<= 1;
if ( c % 8 == 0 )
cout << ' ';
} // end for
cout << endl;
Enter an unsigned integer: 330

Before bits are reversed:
330 = 00000000 00000000 00000001 01001010
After bits are reversed:
21648000 = 00000001 01001010 01010010 10000000
22.16 Write a program that demonstrates passing an array by value. [Hint: Use a struct.] Prove
that a copy was passed by modifying the array copy in the called function.
22.17 Write a program that inputs a character from the keyboard and tests the character with each
function in the character-handling library. Print the value returned by each function.
Exercises
17
22.18 The following program uses function multiple to determine whether the integer entered
from the keyboard is a multiple of some integer X. Examine function multiple, then determine the
value of X.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// Exercise 22.18: ex22_18.cpp

// This program determines if a value is a multiple of X.
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
bool multiple( int );
int main()
{
int y;
cout << "Enter an integer between 1 and 32000: ";
cin >> y;
if ( multiple( y ) )
cout << y << " is a multiple of X" << endl;
else
cout << y << " is not a multiple of X" << endl;
return 0;
} // end main
// determine if num is a multiple of X
bool multiple( int num )
{
bool mult = true;
for ( int i = 0, mask = 1; i < 10; i++, mask <<= 1 )
if ( ( num & mask ) != 0 )
{
mult = false;
break;
} // end if
return mult;
} // end function multiple
ANS: The value of X is 1024.
18
22.19 What does the following program do?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Exercise 22.19: ex22_19.cpp

#include <iostream>
using std::cout;
using std::cin;
using std::endl;
using std::boolalpha;
bool mystery( unsigned );
int main()
{
unsigned x;
cout << "Enter an integer: ";
cin >> x;
cout << boolalpha
<< "The result is " << mystery( x ) << endl;
return 0;
} // end main
// What does this function do?
bool mystery( unsigned bits )
{
unsigned total = 0;
for ( int i = 0; i < SHIFT + 1; i++, bits <<= 1 )
if ( ( bits & MASK ) == MASK )
total++;
return !( total % 2 );
} // end function mystery
ANS: The program prints false if the total number of 1s in the bit representation is odd,
and prints true if the number of 1s is even.
22.20 Write a program that inputs a line of text with istream member function getline (as in
Chapter 15) into character array s[ 100 ]. Output the line in uppercase letters and lowercase letters.
ANS:
1
2
3
4
5
6
7
8

#include <iostream>
using std::cout;
using std::cin;
using std::endl;
#include <cctype>
using std::toupper;
Exercises
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
19
using std::tolower;
const int SIZE = 100;
int main()
{
char s[ SIZE ];
int i;
cout << "Enter a line of text:\n";
cin.getline( s, SIZE );
cout << "\nThe line in uppercase is:\n";
// demonstrate function toupper
for ( i = 0; s[ i ] != '\0'; ++i )
cout << static_cast< char >( toupper( s[ i ] ) );
cout << "\n\nThe line in lowercase is:\n";
// demonstrate function tolower
for ( i = 0; s[ i ] != '\0'; ++i )
cout << static_cast< char >( tolower( s[ i ] ) );
cout << endl;
return 0;
} // end main
Enter a line of text:

CPPHTP5 Instructor's Manual
The line in uppercase is:
CPPHTP5 INSTRUCTOR'S MANUAL
The line in lowercase is:
cpphtp5 instructor's manual
22.21 Write a program that inputs four strings that represent integers, converts the strings to integers, sums the values and prints the total of the four values. Use only the C-style string-processing
techniques shown in this chapter.
ANS:
1
2
3
4
5
6
7
8
9
10

#include <iostream>
using std::cout;
using std::endl;
using std::cin;
#include <cstdlib>
using std::atoi;
const int SIZE = 6;
20
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
int main()
{
char stringValue[ SIZE ];
int sum = 0;
for ( int i = 1; i <= 4; ++i )
{
cout << "Enter an integer string: ";
cin >> stringValue;
sum += atoi( stringValue ); // add converted stringValue to sum
} // end for
cout << "The total of the values is " << sum << endl;
return 0;
} // end main
Enter an integer
Enter an integer
Enter an integer
Enter an integer
The total of the
string: 11
string: 22
string: 44
string: 88
values is 165
22.22 Write a program that inputs four strings that represent floating-point values, converts the
strings to double values, sums the values and prints the total of the four values. Use only the C-style
string-processing techniques shown in this chapter.
ANS:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <iostream>
using std::cout;
using std::endl;
using std::cin;
#include <iomanip>
using std::setw;
using std::fixed;
using std::setprecision;
#include <cstdlib>
using std::atof;
int main()
{
char stringValue[ SIZE ];
double sum = 0.0;
for ( int i = 1; i <= 4; i++ )
{
cout << "Enter a floating-point value: ";
Exercises
25
26
27
28
29
30
31
32
33
21
cin >> stringValue;

sum += atof( stringValue ); // convert to double
} // end for
cout << fixed << "\nThe total of the values is " << setprecision( 3 )
<< sum << endl;
return 0;
} // end main
Enter
Enter
Enter
Enter
a
a
a
a
floating-point
floating-point
floating-point
floating-point
value:
value:
value:
value:
4.3
6.4
2.4
7.2
The total of the values is 20.300
22.23 Write a program that inputs a line of text and a search string from the keyboard. Using
function strstr, locate the first occurrence of the search string in the line of text, and assign the
location to variable searchPtr of type char *. If the search string is found, print the remainder of
the line of text beginning with the search string. Then use strstr again to locate the next occurrence
of the search string in the line of text. If a second occurrence is found, print the remainder of the
line of text beginning with the second occurrence. [Hint: The second call to strstr should contain
the expression searchPtr + 1 as its first argument.]
ANS:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <iostream>
using std::cout;
using std::cin;
#include <cstring>
using std::strstr;
const int SIZE1 = 80;
int main()
{
char text[ SIZE1 ]; // char array for text input
char search[ SIZE2 ]; // char array for searching
char *searchPtr;
// ask user for text input
cout << "Enter a line of text:\n";
cin.get( text, SIZE1 );
// ask for a search string
cout << "\nEnter a search string: ";
cin >> search;
22
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
// demonstrates usage of function strstr to locate occurrences

// of search in text
searchPtr = strstr( text, search );
if ( searchPtr )
{
cout << "\nThe remainder of the line beginning with\n"
<< "the first occurrence of \"" << search << "\":\n"
<< searchPtr << '\n';
searchPtr = strstr( searchPtr + 1, search );
if ( searchPtr ) // second occurrence of search string
cout << "\nThe remainder of the line beginning with"
<< "\nthe second occurrence of \"" << search << "\":\n"
<< searchPtr << '\n';
else
cout << "\nThe search string appeared only once.\n";
} // end if
else
cout << "\"" << search << "\" not found.\n";
return 0;
} // end main
Enter a line of text:

I like to eat apples and bananas
Enter a search string: an
The remainder of the line beginning with
the first occurrence of "an":
and bananas
The remainder of the line beginning with
the second occurrence of "an":
ananas
22.24 Write a program based on the program of Exercise 22.23 that inputs several lines of text and
a search string, then uses function strstr to determine the total number of occurrences of the string
in the lines of text. Print the result.
ANS:
1
2
3
4
5
6
7
8
9

#include <iostream>
using std::cout;
using std::endl;
using std::cin;
#include <cstring>
using std::strstr;
Exercises
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#include <cctype>
using std::tolower;
int main()
{
char text[ 3 ][ SIZE1 ];
char search[ SIZE2 ];
char *searchPtr;
int count = 0;
int i;
cout << "Enter three lines of text:\n";
for ( i = 0; i <= 2; i++ )
cin.getline( &text[ i ][ 0 ], SIZE1 );
// make all characters lowercase
for ( i = 0; i <= 2; i++ )
for ( int j = 0; text[ i ][ j ] != '\0'; j++ )
{
char c = static_cast< char >( tolower( text[ i ][ j ] ) );
text[ i ][ j ] = c;
} // end for
cout << "\nEnter a search string: ";
cin >> search;
for ( i = 0; i <= 2; i++ )
{
searchPtr = &text[ i ][ 0 ];
while ( searchPtr = strstr( searchPtr, search ) )
{
count++;
searchPtr++;
} // end while
} // end for
cout << "\nThe total number of occurrences of \"" << search
<< "\" in the text is: " << count << endl;
return 0;
} // end main
23
24
Enter three lines of text:

The first line of text
The second line of text
The third line of text
Enter a search string: line
The total number of occurrences of "line" in the text is: 3
22.25 Write a program that inputs several lines of text and a search character and uses function
strchr to determine the total number of occurrences of the character in the lines of text.
ANS:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#include <iostream>
using std::cout;
using std::endl;
using std::cin;
#include <cstring>
using std::strchr;
#include <cctype>
using std::tolower;
int main()
{
char text[ 3 ][ SIZE ];
char search;
char *searchPtr;
int count = 0;
int i;
for ( i = 0; i <= 2; i++ )
cin.getline( &text[ i ][ 0 ], SIZE );
// make all characters lowercase
for ( i = 0; i <= 2; i++ )
for ( int j = 0; text[ i ][ j ] != '\0'; j++ )
{
char c = static_cast< char >( tolower( text[ i ][ j ] ) );
text[ i ][ j ] = c;
} // end for
cout << "\nEnter a search character: ";
cin >> search;
Exercises
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
25
for ( i = 0; i <= 2; i++ )

{
searchPtr = &text[ i ][ 0 ];
while ( searchPtr = strchr( searchPtr, search ) )
{
count++;
searchPtr++;
} // end while
} // end for
cout << "\nThe total number of occurrences of \'" << search
<< "\' in the text is: " << count << endl;
return 0;
} // end main

Enter a search character: e
The total number of occurrences of 'e' in the text is: 10
22.26 Write a program based on the program of Exercise 22.25 that inputs several lines of text
and uses function strchr to determine the total number of occurrences of each letter of the alphabet
in the text. Uppercase and lowercase letters should be counted together. Store the totals for each
letter in an array, and print the values in tabular format after the totals have been determined.
ANS:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include <iostream>
using std::cout;
using std::endl;
using std::cin;
#include <iomanip>
using std::setw;
#include <cstring>
using std::strchr;
#include <cctype>
using std::tolower;
int main()
{
26
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
char text[ 3 ][ SIZE1 ];

char *searchPtr;
int characters[ SIZE2 ] = { 0 };
for ( int i = 0; i <= 2; i++ )
cin.getline( &text[ i ][ 0 ], SIZE1 );
// convert letters to lowercase
for ( int k = 0; k <= 2; k++ )
for ( int j = 0; text[ k ][ j ] != '\0'; j++ )
{
char c = static_cast< char >( tolower( text[ k ][ j ] ) );
text[ k ][ j ] = c;
} // end for
// run through the alphabet
for ( int q = 0; q < SIZE2; q++ )
{
for ( int j = 0; j <= 2; j++ )
{
searchPtr = &text[ j ][ 0 ];
while ( searchPtr = strchr( searchPtr, 'a' + q ) )
{
characters[ q ]++; // increment each time the character occurs
searchPtr++;
} // end while
} // end inner for
} // end outer for
cout << "\nThe total number of occurrences of each character:\n";
for ( int w = 0; w < SIZE2; w++ )
cout << setw( 3 ) << static_cast< char >( 'a' + w ) << ':'
<< setw( 3 ) << characters[ w ] << '\n';
return 0;
} // end main
Exercises
27

The total number of occurrences of each character:
a: 0
b: 0
c: 1
d: 2
e: 10
f: 4
g: 0
h: 4
i: 5
j: 0
k: 0
l: 3
m: 0
n: 4
o: 4
p: 0
q: 0
r: 2
s: 2
t: 11
u: 0
v: 0
w: 0
x: 3
y: 0
z: 0
22.27 The chart in Appendix B shows the numeric code representations for the characters in the
ASCII character set. Study this chart, and then state whether each of the following is true or false:
a) The letter A comes before the letter B.
ANS: True.
b) The digit 9 comes before the digit 0.
ANS: False.
c) The commonly used symbols for addition, subtraction, multiplication and division all
come before any of the digits.
ANS: True.
d) The digits come before the letters.
ANS: True.
e) If a sort program sorts strings into ascending sequence, then the program will place the
symbol for a right parenthesis before the symbol for a left parenthesis.
ANS: False.
28
22.28 Write a program that reads a series of strings and prints only those strings beginning with
the letter b.
ANS:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include <iostream>
using std::cout;
using std::cin;
int main()
{
char array[ 5 ][ SIZE ];
int i;
// take in five strings
for ( i = 0; i <= 4; i++ )
{
cout << "Enter a string: ";
cin.getline( &array[ i ][ 0 ], SIZE );
} // end for
cout << "\nThe strings starting with 'b' are:\n";
// run through the array and see if any string started with 'b'
for ( i = 0; i <= 4; i++ )
if ( array[ i ][ 0 ] == 'b' )
cout << &array[ i ][ 0 ] << '\n'; // print out the string
return 0;
} // end main
Enter
Enter
Enter
Enter
Enter
a
a
a
a
a
string:
string:
string:
string:
string:
apples
bananas
blueberries
tomatoes
bread
The strings starting with 'b' are:

bananas
blueberries
bread
22.29 Write a program that reads a series of strings and prints only those strings that end with the
letters ED.
ANS:
1
2

#include <iostream>
Exercises
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
using std::cout;
using std::cin;
#include <cstring>
using std::strlen;
using std::strcmp;
int main()
{
int length, i;
char array[ 5 ][ SIZE ];
// takes five strings and store into character array
for ( i = 0; i <= 4; i++ )
{
cout << "Enter a string: ";
cin.getline( &array[ i ][ 0 ], SIZE );
} // end for
cout << "\nThe strings ending with \"ED\" are:\n";
// review each string
for ( i = 0; i <= 4; i++ )
{
length = strlen( &array[ i ][ 0 ] );
// check if string ends with "ED"
if ( strcmp( &array[ i ][ length - 2 ], "ED" ) == 0 )
cout << &array[ i ][ 0 ] << '\n';
} // end for
return 0;
} // end main
Enter
Enter
Enter
Enter
Enter
a
a
a
a
a
string:
string:
string:
string:
string:
MOVED
SAW
RAN
CARVED
PROVED
The strings ending with "ED" are:

MOVED
CARVED
PROVED
29
30
22.30 Write a program that inputs an ASCII code and prints the corresponding character. Modify
this program so that it generates all possible three-digit codes in the range 000255 and attempts to
print the corresponding characters. What happens when this program is run?
ANS:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// Exercise 22.30 Solution Part a: ex22_30a.cpp

// Printing ASCII characters based on codes entered by the user.
#include <iostream>
using std::cout;
using std::cin;
int main()
{
int c;
cout << "Enter an ASCII character code (-1 to end): ";
cin >> c;
// loop until user enters -1
while ( c != -1 )
{
if ( c >= 0 && c <= 255 )
cout << "The corresponding character is '"
<< static_cast< char > ( c ) << "\'\n";
else
cout << "Invalid character code\n";
// ask for another character
cout << "\nEnter an ASCII character code (-1 to end): ";
cin >> c;
} // end while
return 0;
} // end main
Enter an ASCII character code (-1 to end): 44

The corresponding character is ','
The corresponding character is 'M'
The corresponding character is '?'
The corresponding character is ' '
Enter an ASCII character code (-1 to end): -1
ANS: [Note: Some of the characters output by this application cannot be displayed properly
on screen.]
1
2
// Exercise 22.30 Solution Part b: ex22_30b.cpp

// Printing the characters corresponding to ASCII codes 0255.
Exercises
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
31
#include <iostream>
using std::cout;
using std::endl;
#include <iomanip>
using std::setw;
int main()
{
for ( int c = 0; c <= 255; c++ )
{
if ( c % 7 == 0 )
cout << '\n';
cout << setw( 6 ) << c << setw( 3 ) << static_cast< char > ( c );
} // end for
cout << endl;
return 0;
} // end main
32
0
7
11
14
21
28
35
42
49
56
63
70
77
84
91
98
105
112
119
126
133
140
147
154
161
168
175
182
189
196
203
210
217
224
231
238
245
252
1
8
12
15
22
29
36
43
50
57
64
71
78
85
92
99
106
113
120
127
134
141
148
155
162
169
176
183
190
197
204
211
218
225
232
239
246
253
?
?
?
#
*
1
8
?
F
M
T
[
b
i
p
w
~
+
+
a
t
e
)
n
?
?
?
?
$
+
2
9
@
G
N
U
\
c
j
q
x
+
+
+
+
+
F
n
13
16
23
30
37
44
51
58
65
72
79
86
93
100
107
114
121
128
135
142
149
156
163
170
177
184
191
198
205
212
219
226
233
240
247
254
?
?
?
%
,
3
:
A
H
O
V
]
d
k
r
y
+
+
G
T
=
17
24
31
38
45
52
59
66
73
80
87
94
101
108
115
122
129
136
143
150
157
164
171
178
185
192
199
206
213
220
227
234
241
248
255
?
?
?
&
4
;
B
I
P
W
^
e
l
s
z
+
+
_
p
O
18 ?
25 ?
32
39 '
46 .
53 5
60 <
67 C
74 J
81 Q
88 X
95 _
102 f
109 m
116 t
123 {
130
137
144
151
158 P
165
172
179
186
193 200 +
207 214 +
221
228 S
235 d
242 =
249
10
19 ?
26 ?
33 !
40 (
47 /
54 6
61 =
68 D
75 K
82 R
89 Y
96 `
103 g
110 n
117 u
124 |
131
138
145
152
159
166
173
180
187 +
194 201 +
208 215 +
222
229 s
236 8
243 =
250
20
27 ?
34 "
41 )
48 0
55 7
62 >
69 E
76 L
83 S
90 Z
97 a
104 h
111 o
118 v
125 }
132
139
146
153
160
167
174
181
188 +
195 +
202 209 216 +
223
230
237 f
244 (
251 v
22.31 Using the ASCII character chart in Appendix B as a guide, write your own versions of the
character-handling functions in Fig. 22.17.
ANS:
1
2
3
4
5
6
7
8
9
10
11

#include <iostream>
using std::cout;
using std::cin;
// prototypes
int isDigit( int
int isAlpha( int
int isAlNum( int
int isLower( int
int isUpper( int
);
);
);
);
);
Exercises
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
int
int
int
int
int
int
isSpace(
isPunct(
isPrint(
isGraph(
toLower(
toUpper(
int
int
int
int
int
int
33
);
);
);
);
);
);
int main()
{
int v;
char a; // hold a character
char header[] = "According to";
char *names[] = { "isDigit ", "isAlpha ", "isAlNum ", "isLower ",
"isUpper ", "isSpace ", "isPunct ", "isPrint ", "isGraph ",
"toLower ", "toUpper " };
char *names2[] = { "digit", "letter", "letter/digit", "lowercase",
"uppercase", "space", "punctuation", "print", "graph",
"converted lowercase", "converted uppercase" };
int ( *f[] )( int ) = { isDigit, isAlpha, isAlNum, isLower,
isUpper, isSpace, isPunct, isPrint,
isGraph, toLower, toUpper };
cout << "Enter a character: ";
cin >> a;
for ( int k = 0; k < 11; ++k )
{
v = ( *f[ k ] )( static_cast< int >( a ) );
cout.write( header, 13 );
cout << names[ k ] << a << ( !v ? " is not a " : " is a " )
<< names2[ k ] << " character\n";
} // end for
return 0;
} // end main
// Normally these would return bool, but int return type
// is consistent with the ctype library.
// determine whether c is an integer
int isDigit( int c )
{
return ( c >= 48 && c <= 57 ) ? 1 : 0;
} // end function isDigit
// return true if c is a letter
int isAlpha( int c )
{
return ( ( c >= 65 && c <= 90 ) || ( c >= 97 && c <= 122 ) ) ? 1 : 0;
} // end function is Alpha
// return true if c is a digit
int isAlNum( int c )
{
34
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
return ( isDigit( c ) == 1 || isAlpha( c ) == 1 ) ? 1 : 0;

} // end function isAlNum
// return true if c is lowercase letter
int isLower( int c )
{
return ( c >= 97 && c <= 122 ) ? 1 : 0;
} // end function isLower
// return true if c is uppercase letter
int isUpper( int c )
{
return ( c >= 65 && c <= 90 ) ? 1 : 0;
} // end function isUpper
// return true if c is whitespace character
int isSpace( int c )
{
return ( ( c == 32 ) || ( c >= 9 && c <= 13 ) ) ? 1 : 0;
} // end function isSpace
// return true if c is a printing character other than a space
int isPunct( int c )
{
return ( isAlNum( c ) == 0 && isSpace( c ) == 0 ) ? 1 : 0;
} // end function isPunct
// return true value if c is a printing variable including space
int isPrint( int c )
{
return ( c >= 32 && c <= 126 ) ? 1 : 0;
} // end function isPrint
// return true if c is a printing character other than space
int isGraph( int c )
{
return ( c >= 33 && c <= 126 ) ? 1 : 0;
} // end function isGraph
// convert to lowercase
int toLower( int c )
{
return ( isUpper( c ) == 1 ) ? c + 32 : c;
} // end function toLower
// convert to uppercase
int toUpper( int c )
{
return ( isLower( c ) == 1 ) ? c - 32 : c;
} // end function toUpper
Exercises
Enter a character: A
According to isDigit,
According to isAlpha,
According to isAlNum,
According to isLower,
According to isUpper,
According to isSpace,
According to isPunct,
According to isPrint,
According to isGraph,
According to toLower,
According to toUpper,
A
A
A
A
A
A
A
A
A
A
A
is
is
is
is
is
is
is
is
is
is
is
not a digit character

a letter character
a letter/digit character
not a lowercase character
a uppercase character
not a space character
not a punctuation character
a print character
a graph character
a converted lowercase character
a converted uppercase character
Enter a character: 4
According to isDigit,
According to isAlpha,
According to isAlNum,
According to isLower,
According to isUpper,
According to isSpace,
According to isPunct,
According to isPrint,
According to isGraph,
According to toLower,
According to toUpper,
4
4
4
4
4
4
4
4
4
4
4
is
is
is
is
is
is
is
is
is
is
is
a digit character
not a letter character
a letter/digit character
not a lowercase character
not a uppercase character
not a space character
not a punctuation character
a print character
a graph character
a converted lowercase character
a converted uppercase character
35
22.32 Write your own versions of the functions in Fig. 22.21 for converting strings to numbers.
22.33 Write your own versions of the functions in Fig. 22.28 for searching strings.
22.34 Write your own versions of the functions in Fig. 22.35 for manipulating blocks of memory.
22.35 (Project: A Spelling Checker) Many popular word-processing software packages have builtin spell checkers. We used spell-checking capabilities in preparing this book and discovered that, no
matter how careful we thought we were in writing a chapter, the software was always able to find a
few more spelling errors than we were able to catch manually.
In this project, you are asked to develop your own spell-checker utility. We make suggestions
to help get you started. You should then consider adding more capabilities. You might nd it helpful to use a computerized dictionary as a source of words.
Why do we type so many words with incorrect spellings? In some cases, it is because we simply do not know the correct spelling, so we make a best guess. In some cases, it is because we
transpose two letters (e.g., defualt instead of default). Sometimes we double-type a letter accidentally (e.g., hanndy instead of handy). Sometimes we type a nearby key instead of the one we
intended (e.g., biryhday instead of birthday). And so on.
Design and implement a spell-checker program. Your program maintains an array wordList of
character strings. You can either enter these strings or obtain them from a computerized dictionary.
Your program asks a user to enter a word. The program then looks up that word in the
wordList array. If the word is present in the array, your program should print Word is spelled
correctly.
If the word is not present in the array, your program should print Word is not spelled correctly. Then your program should try to locate other words in wordList that might be the word
the user intended to type. For example, you can try all possible single transpositions of adjacent let-
36
ters to discover that the word default is a direct match to a word in wordList. Of course, this
implies that your program will check all other single transpositions, such as edfault, dfeault,
deafult, defalut and defautl. When you nd a new word that matches one in wordList, print
that word in a message such as Did you mean "default?".
Implement other tests, such as the replacing of each double letter with a single letter and any
other tests you can develop to improve the value of your spell checker.

Язык

Добро пожаловать в Scribd!

Cpphtp5 22 IM

Загружено:

Сведения о документе

Описание:

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Описание:

Авторское право:

Доступные форматы

Cpphtp5 22 IM

Загружено:

Описание:

Авторское право:

Доступные форматы

Похожие издания

22

The same old charitable lie

The chief defect of Henry

To create and use structs.

To pass structs to functions by value and by reference.

Vigorous writing is concise.

To use typedef to create aliases for previously dened

Chapter 22 Bits, Characters, C-Strings and structs

Fill in the blanks in each of the following:

Write a single statement or a set of statements to accomplish each of the following:

b) Define PartPtr to be a synonym for the type Part *.

c) Use separate statements to declare variable a to be of type Part, array b[

e) Assign the member values of variable a to element three of array b.

f) Assign the address of array b to the pointer variable ptr.

Find the error in each of the following:

der of evaluation of the expression to be incorrect.

ANS: Error: A semicolon is required to end a structure definition.

Chapter 22 Bits, Characters, C-Strings and structs

to an uppercase letter. Assign the result to

c) Convert the string "1234567" to long, and print the value.

<< " control character" << endl;

e) Assign to ptr the location of the last occurrence of c in s1.

f) Convert the string "8.63582" to double, and print the value.

ANS: out << atof( "8.63582" ) << endl;

ANS: cout << '\'' << c << "\' "

h) Assign to ptr the location of the first occurrence of s2 in s1.

k) Assign to ptr the location of the first occurrence of c in s1.

l) Convert the string "-21" to int, and print the value.

Provide the definition for each of the following structures:

ANS: struct Inventory

b) A structure called Address that contains character arrays streetAddress[

ANS: struct Address

c) Structure Student, containing arrays firstName[ 15 ] and lastName[

ANS: struct Student

Consider the following structure definitions and variable declarations:

b) Member lastName of the structure pointed to by customerPtr.

c) Member firstName of structure customerRecord.

Chapter 22 Bits, Characters, C-Strings and structs

e) Member customerNumber of structure customerRecord.

f) Member customerNumber of the structure pointed to by customerPtr.

g) Member phoneNumber of member personal of structure customerRecord.

h) Member phoneNumber of member personal of the structure pointed to by customerPtr.

i) Member address of member personal of structure customerRecord.

j) Member address of member personal of the structure pointed to by customerPtr.

k) Member city of member personal of structure customerRecord.

l) Member city of member personal of the structure pointed to by customerPtr.

m) Member state of member personal of structure customerRecord.

n) Member state of member personal of the structure pointed to by customerPtr.

o) Member zipCode of member personal of structure customerRecord.

p) Member zipCode of member personal of the structure pointed to by customerPtr.

// Exercise 22.8 Solution: DeckOfCards.h

BitCard deck[ 52 ]; // represents deck of cards

// Exercise 22.8 Solution: DeckOfCards.cpp

Chapter 22 Bits, Characters, C-Strings and structs

// Exercise 22.8 Solution: ex22_08.cpp

// Exercise 22.9 Solution: ex22_09.cpp

Chapter 22 Bits, Characters, C-Strings and structs

Enter an integer: 5345